typing.h

Go to the documentation of this file.

/*
 * Copyright 2015-2017 Two Pore Guys, Inc.
 * All rights reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted providing that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef LIBRPC_TYPING_H
#define LIBRPC_TYPING_H

#include <rpc/object.h>

#ifdef __cplusplus
extern "C" {
#endif

#define RPCT_TYPING_INTERFACE   "com.twoporeguys.librpc.Typing"
#define RPCT_TYPE_FIELD     "%type"
#define RPCT_VALUE_FIELD    "%value"

struct rpct_type;
struct rpct_typei;
struct rpct_member;
struct rpct_interface;
struct rpct_if_member;
struct rpct_argument;

typedef struct rpct_type *rpct_type_t;

typedef struct rpct_typei *rpct_typei_t;

typedef struct rpct_member *rpct_member_t;

typedef struct rpct_interface *rpct_interface_t;

typedef struct rpct_argument *rpct_argument_t;

typedef struct rpct_if_member *rpct_if_member_t;

typedef enum {
    RPC_TYPING_STRUCT,      
    RPC_TYPING_UNION,       
    RPC_TYPING_ENUM,        
    RPC_TYPING_TYPEDEF,     
    RPC_TYPING_CONTAINER,       
    RPC_TYPING_BUILTIN      
} rpct_class_t;

typedef bool (^rpct_type_applier_t)(rpct_type_t);

typedef bool (^rpct_member_applier_t)(rpct_member_t);

typedef bool (^rpct_interface_applier_t)(rpct_interface_t);

typedef bool (^rpct_if_member_applier_t)(rpct_if_member_t);

#define RPCT_TYPE_APPLIER(_fn, _arg)                    \
    ^(rpct_type_t _type) {                      \
        return ((bool)_fn(_arg, _type));            \
    }

#define RPCT_INTERFACE_APPLIER(_fn, _arg)               \
    ^(rpct_interface_t _iface) {                    \
        return ((bool)_fn(_arg, _iface));           \
    }

#define RPCT_MEMBER_APPLIER(_fn, _arg)                  \
    ^(rpct_member_t _member) {                  \
        return ((bool)_fn(_arg, _member));          \
    }

#define RPCT_IF_MEMBER_APPLIER(_fn, _arg)               \
    ^(rpct_if_member_t _if_member) {                \
        return ((bool)_fn(_arg, _if_member));           \
    }

int rpct_init(bool load_system_types);

void rpct_free(void);

int rpct_read_file(const char *path);

int rpct_read_idl(const char *name, rpc_object_t idl);

int rpct_load_types(const char *path);

int rpct_load_types_dir(const char *path);

int rpct_load_types_stream(int fd);

int rpct_load_types_cached(void);

const char *rpct_type_get_name(rpct_type_t type);

const char *rpct_type_get_origin(rpct_type_t iface);

const char *rpct_type_get_module(rpct_type_t type);

const char *rpct_type_get_description(rpct_type_t type);

rpct_type_t rpct_type_get_parent(rpct_type_t type);

rpct_class_t rpct_type_get_class(rpct_type_t type);

rpct_typei_t rpct_type_get_definition(rpct_type_t type);

int rpct_type_get_generic_vars_count(rpct_type_t type);

const char *rpct_type_get_generic_var(rpct_type_t type, int index);

rpct_member_t rpct_type_get_member(rpct_type_t type, const char *name);

rpct_typei_t rpct_typei_retain(rpct_typei_t typei);

void rpct_typei_release(rpct_typei_t typei);

bool rpct_typei_get_proxy(rpct_typei_t typei);

const char *rpct_typei_get_proxy_variable(rpct_typei_t typei);

rpct_type_t rpct_typei_get_type(rpct_typei_t typei);

rpct_typei_t rpct_typei_get_generic_var(rpct_typei_t typei, const char *name);

const char *rpct_typei_get_canonical_form(rpct_typei_t typei);

rpct_typei_t rpct_typei_get_member_type(rpct_typei_t typei,
    rpct_member_t member);

bool rpct_typei_is_compatible(rpct_typei_t decl, rpct_typei_t type);

const char *rpct_member_get_name(rpct_member_t member);

const char *rpct_member_get_description(rpct_member_t member);

rpct_typei_t rpct_member_get_typei(rpct_member_t member);

const char *rpct_interface_get_name(rpct_interface_t iface);

const char *rpct_interface_get_origin(rpct_interface_t iface);

const char *rpct_interface_get_description(rpct_interface_t iface);

enum rpc_if_member_type rpct_if_member_get_type(rpct_if_member_t member);

const char *rpct_if_member_get_name(rpct_if_member_t member);

const char *rpct_if_member_get_description(rpct_if_member_t member);

rpct_typei_t rpct_method_get_return_type(rpct_if_member_t method);

int rpct_method_get_arguments_count(rpct_if_member_t method);

rpct_argument_t rpct_method_get_argument(rpct_if_member_t method, int index);

rpct_typei_t rpct_property_get_type(rpct_if_member_t prop);

const char *rpct_argument_get_name(rpct_argument_t arg);

const char *rpct_argument_get_description(rpct_argument_t arg);

rpct_typei_t rpct_argument_get_typei(rpct_argument_t arg);

bool rpct_types_apply(rpct_type_applier_t applier);

bool rpct_members_apply(rpct_type_t type, rpct_member_applier_t applier);

bool rpct_interface_apply(rpct_interface_applier_t applier);

bool rpct_if_member_apply(rpct_interface_t iface, rpct_if_member_applier_t applier);

rpct_interface_t rpct_find_interface(const char *name);

rpct_if_member_t rpct_find_if_member(const char *interface, const char *member);

rpct_typei_t rpct_new_typei(const char *decl);

rpc_object_t rpct_new(const char *decl, rpc_object_t object);

rpc_object_t rpct_newi(rpct_typei_t typei, rpc_object_t object);

rpc_object_t rpct_set_typei(rpct_typei_t typei, rpc_object_t object);

rpct_type_t rpct_get_type(const char *name);

rpct_typei_t rpct_get_typei(rpc_object_t instance);

rpc_object_t rpct_get_value(rpc_object_t instance);

void rpct_set_value(rpc_object_t object, const char *value);

rpc_object_t rpct_serialize(rpc_object_t object);

rpc_object_t rpct_deserialize(rpc_object_t object);

bool rpct_validate_args(struct rpct_if_member *func, rpc_object_t args,
    rpc_object_t *errors);

bool rpct_validate_return(struct rpct_if_member *func, rpc_object_t result,
    rpc_object_t *errors);

bool rpct_validate(rpct_typei_t typei, rpc_object_t obj, rpc_object_t *errors);

rpc_object_t rpct_pre_call_hook(void *cookie, rpc_object_t args);

rpc_object_t rpct_post_call_hook(void *cookie, rpc_object_t args);

void rpct_allow_idl_download(rpc_context_t context);

int rpct_download_idl(rpc_connection_t conn);

#ifdef __cplusplus
}
#endif

#endif /* LIBRPC_TYPING_H */