lo_lowlevel.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004 Steve Harris
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public License
 *  as published by the Free Software Foundation; either version 2.1
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  $Id$
 */

#ifndef LO_LOWLEVEL_H
#define LO_LOWLEVEL_H

#include "lo/lo_osc_types.h"

#ifdef __cplusplus
extern "C" {
#endif

#include <stdarg.h>
#ifdef _MSC_VER
#define ssize_t SSIZE_T
#define uint32_t unsigned __int32
#else
#include <stdint.h>
#endif

#include "lo/lo_types.h"
#include "lo/lo_errors.h"

typedef long double lo_hires;




int lo_send_message(lo_address targ, const char *path, lo_message msg);

int lo_send_message_from(lo_address targ, lo_server serv, 
     const char *path, lo_message msg);

int lo_send_bundle(lo_address targ, lo_bundle b);

int lo_send_bundle_from(lo_address targ, lo_server serv, lo_bundle b);

lo_message lo_message_new();

void lo_message_free(lo_message m);

int lo_message_add(lo_message m, const char *types, ...);

int lo_message_add_internal(lo_message m,  const char *file, const int line,
                            const char *types, ...);

int lo_message_add_varargs(lo_message m, const char *types, va_list ap);

int lo_message_add_varargs_internal(lo_message m, const char *types, va_list ap,
                                    const char *file, const int line);

int lo_message_add_int32(lo_message m, int32_t a);

int lo_message_add_float(lo_message m, float a);

int lo_message_add_string(lo_message m, const char *a);

int lo_message_add_blob(lo_message m, lo_blob a);

int lo_message_add_int64(lo_message m, int64_t a);

int lo_message_add_timetag(lo_message m, lo_timetag a);

int lo_message_add_double(lo_message m, double a);

int lo_message_add_symbol(lo_message m, const char *a);

int lo_message_add_char(lo_message m, char a);

int lo_message_add_midi(lo_message m, uint8_t a[4]);

int lo_message_add_true(lo_message m);

int lo_message_add_false(lo_message m);

int lo_message_add_nil(lo_message m);

int lo_message_add_infinitum(lo_message m);

lo_address lo_message_get_source(lo_message m);

lo_timetag lo_message_get_timestamp(lo_message m);

char *lo_message_get_types(lo_message m);

int lo_message_get_argc(lo_message m);

lo_arg **lo_message_get_argv(lo_message m);

size_t lo_message_length(lo_message m, const char *path);

void *lo_message_serialise(lo_message m, const char *path, void *to,
               size_t *size);

lo_message lo_message_deserialise(void *data, size_t size, int *result);

int lo_server_dispatch_data(lo_server s, void *data, size_t size);

const char *lo_address_get_hostname(lo_address a);

const char *lo_address_get_port(lo_address a);

int lo_address_get_protocol(lo_address a);

char *lo_address_get_url(lo_address a);

void lo_address_set_ttl(lo_address t, int ttl);

int lo_address_get_ttl(lo_address t);

lo_bundle lo_bundle_new(lo_timetag tt);

int lo_bundle_add_message(lo_bundle b, const char *path, lo_message m);

size_t lo_bundle_length(lo_bundle b);

void *lo_bundle_serialise(lo_bundle b, void *to, size_t *size);

void lo_bundle_free(lo_bundle b);

void lo_bundle_free_messages(lo_bundle b);

int lo_is_numerical_type(lo_type a);

int lo_is_string_type(lo_type a);

int lo_coerce(lo_type type_to, lo_arg *to, lo_type type_from, lo_arg *from);

lo_hires lo_hires_val(lo_type type, lo_arg *p);

lo_server lo_server_new(const char *port, lo_err_handler err_h);

lo_server lo_server_new_with_proto(const char *port, int proto,
                                   lo_err_handler err_h);

lo_server lo_server_new_multicast(const char *group, const char *port,
                                  lo_err_handler err_h);

void lo_server_free(lo_server s);

int lo_server_wait(lo_server s, int timeout);

int lo_server_recv_noblock(lo_server s, int timeout);

int lo_server_recv(lo_server s);

lo_method lo_server_add_method(lo_server s, const char *path,
                               const char *typespec, lo_method_handler h,
                               void *user_data);

void lo_server_del_method(lo_server s, const char *path,
                               const char *typespec);

int lo_server_get_socket_fd(lo_server s);

int lo_server_get_port(lo_server s);

int lo_server_get_protocol(lo_server s);

char *lo_server_get_url(lo_server s);

int lo_server_events_pending(lo_server s);

double lo_server_next_event_delay(lo_server s);

char *lo_url_get_protocol(const char *url);

int lo_url_get_protocol_id(const char *url);

char *lo_url_get_hostname(const char *url);

char *lo_url_get_port(const char *url);

char *lo_url_get_path(const char *url);

/* utility functions */

int lo_strsize(const char *s);

uint32_t lo_blobsize(lo_blob b);

int lo_pattern_match(const char *str, const char *p);

int lo_send_internal(lo_address t, const char *file, const int line,
     const char *path, const char *types, ...);
int lo_send_timestamped_internal(lo_address t, const char *file, const int line,
     lo_timetag ts, const char *path, const char *types, ...);
int lo_send_from_internal(lo_address targ, lo_server from, const char *file, 
     const int line, const lo_timetag ts, 
     const char *path, const char *types, ...);


double lo_timetag_diff(lo_timetag a, lo_timetag b);

void lo_timetag_now(lo_timetag *t);

size_t lo_arg_size(lo_type type, void *data);

char *lo_get_path(void *data, ssize_t size);

void lo_arg_host_endian(lo_type type, void *data);

void lo_arg_network_endian(lo_type type, void *data);

/* prettyprinters */

void lo_bundle_pp(lo_bundle b);

void lo_message_pp(lo_message m);

void lo_arg_pp(lo_type type, void *data);

void lo_server_pp(lo_server s);

void lo_method_pp(lo_method m);

void lo_method_pp_prefix(lo_method m, const char *p);

void lo_server_thread_pp(lo_server_thread st);
#ifdef __cplusplus
}
#endif

#endif

---