lo_lowlevel.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2014 Steve Harris et al. (see AUTHORS)
 *
 *  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>
#include <sys/types.h>
#ifdef _MSC_VER
#include <BaseTsd.h>
typedef SSIZE_T ssize_t;
#endif
#include <stdint.h>
 
 
#include "lo/lo_types.h"
#include "lo/lo_errors.h"
 
typedef long double lo_hires;
 
 
typedef struct {
    size_t size;
    const char *group;
    const char *port;
    const char *iface;
    const char *ip;
    int proto;
    lo_err_handler err_handler;
    void *err_handler_context;
} lo_server_config;
 
typedef enum {
        LO_SLIP_NONE   = 0,
        LO_SLIP_SINGLE = 1,
        LO_SLIP_DOUBLE = 2
} lo_slip_encoding;
 
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);
 
void lo_message_incref(lo_message m);
 
lo_message lo_message_clone(lo_message m);
 
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);
 
int lo_address_set_iface(lo_address t, const char *iface, const char *ip);
 
const char* lo_address_get_iface(lo_address t);
 
int lo_address_set_tcp_nodelay(lo_address t, int enable);
 
int lo_address_set_stream_slip(lo_address t, lo_slip_encoding encoding);
 
lo_bundle lo_bundle_new(lo_timetag tt);
 
void lo_bundle_incref(lo_bundle b);
 
int lo_bundle_add_message(lo_bundle b, const char *path, lo_message m);
 
int lo_bundle_add_bundle(lo_bundle b, lo_bundle n);
 
size_t lo_bundle_length(lo_bundle b);
 
unsigned int lo_bundle_count(lo_bundle b);
 
lo_element_type lo_bundle_get_type(lo_bundle b, int index);
 
lo_bundle lo_bundle_get_bundle(lo_bundle b, int index);
 
lo_message lo_bundle_get_message(lo_bundle b, int index,
                                 const char **path);
 
lo_timetag lo_bundle_get_timestamp(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_recursive(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);
 
lo_server lo_server_new_multicast_iface(const char *group, const char *port,
                                        const char *iface, const char *ip,
                                        lo_err_handler err_h);
 
lo_server lo_server_new_from_url(const char *url,
                                 lo_err_handler err_h);
 
lo_server lo_server_new_from_config(lo_server_config *config);
 
int lo_server_enable_coercion(lo_server server, int enable);
 
void lo_server_free(lo_server s);
 
int lo_server_wait(lo_server s, int timeout);
 
int lo_servers_wait(lo_server *s, int *status, int num_servers, int timeout);
 
int lo_server_recv_noblock(lo_server s, int timeout);
 
int lo_servers_recv_noblock(lo_server *s, int *recvd, int num_servers,
                            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,
                               const void *user_data);
 
void lo_server_del_method(lo_server s, const char *path,
                               const char *typespec);
 
int lo_server_del_lo_method(lo_server s, lo_method m);
 
int lo_server_add_bundle_handlers(lo_server s,
                                  lo_bundle_start_handler sh,
                                  lo_bundle_end_handler eh,
                                  void *user_data);
 
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_enable_queue(lo_server s, int queue_enabled,
                           int dispatch_remaining);
 
int lo_server_events_pending(lo_server s);
 
double lo_server_next_event_delay(lo_server s);
 
int lo_server_max_msg_size(lo_server s, int req_size);
 
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_string_contains_pattern(const char *str);
 
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);
 
#ifdef __cplusplus
}
#endif
 
#endif