#ifndef RUSTORB_RUSTORB_H
#define RUSTORB_RUSTORB_H
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#define RORB_ABI_VERSION 3
typedef struct rorb_orb rorb_orb;
typedef struct rorb_object rorb_object;
typedef struct rorb_poa rorb_poa;
typedef struct rorb_poa_manager rorb_poa_manager;
typedef struct rorb_servant rorb_servant;
typedef struct rorb_out rorb_out;
typedef struct rorb_in rorb_in;
typedef struct rorb_server_reply rorb_server_reply;
typedef struct rorb_typecode rorb_typecode;
typedef struct rorb_any rorb_any;
typedef struct rorb_request rorb_request;
typedef struct rorb_server_request rorb_server_request;
typedef int32_t rorb_status;
#define RORB_OK 0
#define RORB_SYSTEM_EXCEPTION 1
#define RORB_USER_EXCEPTION 2
#define RORB_LOCAL_EXCEPTION 3
#define RORB_CALLBACK_FAILED 4
#define RORB_COMPLETED_YES 0
#define RORB_COMPLETED_NO 1
#define RORB_COMPLETED_MAYBE 2
#define RORB_ADAPTER_ALREADY_EXISTS 1
#define RORB_ADAPTER_NON_EXISTENT 2
#define RORB_INVALID_POLICY 3
#define RORB_SERVANT_ALREADY_ACTIVE 4
#define RORB_OBJECT_ALREADY_ACTIVE 5
#define RORB_SERVANT_NOT_ACTIVE 6
#define RORB_OBJECT_NOT_ACTIVE 7
#define RORB_WRONG_POLICY 8
#define RORB_WRONG_ADAPTER 9
#define RORB_ADAPTER_INACTIVE 10
#define RORB_NO_SERVANT 11
#define RORB_NO_CONTEXT 12
#define RORB_INVALID_NAME 13
#define RORB_TC_BAD_KIND 14
#define RORB_TC_BOUNDS 15
#define RORB_POLICY_ERROR 16
#define RORB_DYN_INVALID_VALUE 17
#define RORB_DYN_TYPE_MISMATCH 18
#define RORB_DYN_INCONSISTENT_TYPECODE 19
#define RORB_DYN_MUST_TRUNCATE 20
#define RORB_INVALID_SLOT 21
#define RORB_DUPLICATE_NAME 22
#define RORB_UNKNOWN_ENCODING 23
#define RORB_CODEC_INVALID_TYPE_FOR_ENCODING 24
#define RORB_CODEC_FORMAT_MISMATCH 25
#define RORB_CODEC_TYPE_MISMATCH 26
#define RORB_MANAGER_ALREADY_EXISTS 27
typedef struct rorb_exception {
char* repository_id;
size_t repository_id_len;
uint32_t minor;
uint32_t completed;
uint32_t local;
uint32_t index;
} rorb_exception;
void rorb_exception_clear(rorb_exception* exc);
typedef struct rorb_bytes {
uint8_t* data;
size_t len;
} rorb_bytes;
void rorb_bytes_free(rorb_bytes bytes);
uint32_t rorb_abi_version(void);
#define RORB_TK_NULL 0
#define RORB_TK_VOID 1
#define RORB_TK_SHORT 2
#define RORB_TK_LONG 3
#define RORB_TK_USHORT 4
#define RORB_TK_ULONG 5
#define RORB_TK_FLOAT 6
#define RORB_TK_DOUBLE 7
#define RORB_TK_BOOLEAN 8
#define RORB_TK_CHAR 9
#define RORB_TK_OCTET 10
#define RORB_TK_ANY 11
#define RORB_TK_TYPECODE 12
#define RORB_TK_PRINCIPAL 13
#define RORB_TK_OBJREF 14
#define RORB_TK_STRUCT 15
#define RORB_TK_UNION 16
#define RORB_TK_ENUM 17
#define RORB_TK_STRING 18
#define RORB_TK_SEQUENCE 19
#define RORB_TK_ARRAY 20
#define RORB_TK_ALIAS 21
#define RORB_TK_EXCEPT 22
#define RORB_TK_LONGLONG 23
#define RORB_TK_ULONGLONG 24
#define RORB_TK_LONGDOUBLE 25
#define RORB_TK_WCHAR 26
#define RORB_TK_WSTRING 27
#define RORB_TK_FIXED 28
#define RORB_TK_VALUE 29
#define RORB_TK_VALUE_BOX 30
#define RORB_TK_NATIVE 31
#define RORB_TK_ABSTRACT_INTERFACE 32
#define RORB_TK_LOCAL_INTERFACE 33
#define RORB_TK_COMPONENT 34
#define RORB_TK_HOME 35
#define RORB_TK_EVENT 36
rorb_typecode* rorb_tc_clone(const rorb_typecode* tc);
void rorb_tc_release(rorb_typecode* tc);
rorb_status rorb_tc_simple(uint32_t kind, rorb_typecode** out, rorb_exception* exc);
rorb_status rorb_tc_string(int32_t wide, uint32_t bound, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_fixed(uint16_t digits, int16_t scale, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_sequence(const rorb_typecode* content, uint32_t bound, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_array(const rorb_typecode* content, uint32_t length, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_alias(uint32_t kind, const char* id, size_t id_len, const char* name,
size_t name_len, const rorb_typecode* content, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_interface(uint32_t kind, const char* id, size_t id_len, const char* name,
size_t name_len, rorb_typecode** out, rorb_exception* exc);
rorb_status rorb_tc_struct(uint32_t kind, const char* id, size_t id_len, const char* name,
size_t name_len, size_t count, const char* const* names,
const size_t* name_lens, const rorb_typecode* const* types,
rorb_typecode** out, rorb_exception* exc);
rorb_status rorb_tc_union(const char* id, size_t id_len, const char* name, size_t name_len,
const rorb_typecode* discriminator, size_t count,
const uint64_t* labels, int32_t default_index,
const char* const* names, const size_t* name_lens,
const rorb_typecode* const* types, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_enum(const char* id, size_t id_len, const char* name, size_t name_len,
size_t count, const char* const* names, const size_t* name_lens,
rorb_typecode** out, rorb_exception* exc);
rorb_status rorb_tc_value(uint32_t kind, const char* id, size_t id_len, const char* name,
size_t name_len, int16_t modifier, const rorb_typecode* base,
size_t count, const char* const* names, const size_t* name_lens,
const rorb_typecode* const* types, const int16_t* visibilities,
rorb_typecode** out, rorb_exception* exc);
rorb_status rorb_tc_recursive(const char* id, size_t id_len, rorb_typecode** out,
rorb_exception* exc);
uint32_t rorb_tc_kind(const rorb_typecode* tc);
rorb_status rorb_tc_id(const rorb_typecode* tc, const char** s, size_t* len,
rorb_exception* exc);
rorb_status rorb_tc_name(const rorb_typecode* tc, const char** s, size_t* len,
rorb_exception* exc);
rorb_status rorb_tc_member_count(const rorb_typecode* tc, uint32_t* count, rorb_exception* exc);
rorb_status rorb_tc_member_name(const rorb_typecode* tc, uint32_t index, const char** s,
size_t* len, rorb_exception* exc);
rorb_status rorb_tc_member_type(const rorb_typecode* tc, uint32_t index, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_member_label(const rorb_typecode* tc, uint32_t index, rorb_any** out,
rorb_exception* exc);
rorb_status rorb_tc_discriminator_type(const rorb_typecode* tc, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_default_index(const rorb_typecode* tc, int32_t* index, rorb_exception* exc);
rorb_status rorb_tc_length(const rorb_typecode* tc, uint32_t* length, rorb_exception* exc);
rorb_status rorb_tc_content_type(const rorb_typecode* tc, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_tc_fixed_digits(const rorb_typecode* tc, uint16_t* digits, rorb_exception* exc);
rorb_status rorb_tc_fixed_scale(const rorb_typecode* tc, int16_t* scale, rorb_exception* exc);
rorb_status rorb_tc_member_visibility(const rorb_typecode* tc, uint32_t index, int16_t* v,
rorb_exception* exc);
rorb_status rorb_tc_type_modifier(const rorb_typecode* tc, int16_t* v, rorb_exception* exc);
rorb_status rorb_tc_concrete_base_type(const rorb_typecode* tc, rorb_typecode** out,
rorb_exception* exc);
int32_t rorb_tc_equal(const rorb_typecode* a, const rorb_typecode* b);
int32_t rorb_tc_equivalent(const rorb_typecode* a, const rorb_typecode* b);
rorb_typecode* rorb_tc_compact(const rorb_typecode* tc);
rorb_typecode* rorb_tc_unaliased(const rorb_typecode* tc);
rorb_any* rorb_any_new(void);
rorb_any* rorb_any_clone(const rorb_any* any);
rorb_any* rorb_any_typed(const rorb_typecode* tc);
void rorb_any_release(rorb_any* any);
rorb_typecode* rorb_any_type(const rorb_any* any);
rorb_status rorb_any_set_type(rorb_any* any, const rorb_typecode* tc, rorb_exception* exc);
int32_t rorb_any_equal(const rorb_any* a, const rorb_any* b);
int32_t rorb_any_label(const rorb_any* any, uint64_t* label);
rorb_status rorb_any_insert(const rorb_typecode* tc,
rorb_status (*write)(void* context, rorb_out* out), void* context,
rorb_any** out, rorb_exception* exc);
rorb_status rorb_any_extract(const rorb_any* any,
rorb_status (*read)(void* context, rorb_in* in), void* context,
rorb_exception* exc);
typedef struct rorb_dynany rorb_dynany;
rorb_status rorb_dynany_create(const rorb_any* any, int32_t truncate, rorb_dynany** out,
rorb_exception* exc);
rorb_status rorb_dynany_from_typecode(const rorb_typecode* tc, rorb_dynany** out,
rorb_exception* exc);
rorb_dynany* rorb_dynany_clone(const rorb_dynany* d);
void rorb_dynany_release(rorb_dynany* d);
uint32_t rorb_dynany_kind(const rorb_dynany* d);
int32_t rorb_dynany_same(const rorb_dynany* a, const rorb_dynany* b);
rorb_status rorb_dynany_type(const rorb_dynany* d, rorb_typecode** out, rorb_exception* exc);
rorb_status rorb_dynany_target_type(const rorb_dynany* d, rorb_typecode** out,
rorb_exception* exc);
rorb_status rorb_dynany_assign(const rorb_dynany* d, const rorb_dynany* other,
rorb_exception* exc);
rorb_status rorb_dynany_from_any(const rorb_dynany* d, const rorb_any* any, rorb_exception* exc);
rorb_status rorb_dynany_to_any(const rorb_dynany* d, rorb_any** out, rorb_exception* exc);
rorb_status rorb_dynany_equal(const rorb_dynany* d, const rorb_dynany* other, int32_t* out,
rorb_exception* exc);
rorb_status rorb_dynany_destroy(const rorb_dynany* d, rorb_exception* exc);
rorb_status rorb_dynany_copy(const rorb_dynany* d, rorb_dynany** out, rorb_exception* exc);
rorb_status rorb_dynany_insert(const rorb_dynany* d, uint32_t kind, const rorb_any* value,
rorb_exception* exc);
rorb_status rorb_dynany_get(const rorb_dynany* d, uint32_t kind, rorb_any** out,
rorb_exception* exc);
rorb_status rorb_dynany_insert_seq(const rorb_dynany* d, uint32_t kind, const rorb_any* value,
rorb_exception* exc);
rorb_status rorb_dynany_get_seq(const rorb_dynany* d, uint32_t kind, rorb_any** out,
rorb_exception* exc);
rorb_status rorb_dynany_insert_dyn_any(const rorb_dynany* d, const rorb_dynany* value,
rorb_exception* exc);
rorb_status rorb_dynany_get_dyn_any(const rorb_dynany* d, rorb_dynany** out,
rorb_exception* exc);
rorb_status rorb_dynany_no_implement(const rorb_dynany* d, rorb_exception* exc);
rorb_status rorb_dynany_seek(const rorb_dynany* d, int32_t index, int32_t* out,
rorb_exception* exc);
rorb_status rorb_dynany_rewind(const rorb_dynany* d, rorb_exception* exc);
rorb_status rorb_dynany_next(const rorb_dynany* d, int32_t* out, rorb_exception* exc);
rorb_status rorb_dynany_component_count(const rorb_dynany* d, uint32_t* out,
rorb_exception* exc);
rorb_status rorb_dynany_current_component(const rorb_dynany* d, rorb_dynany** out,
rorb_exception* exc);
rorb_status rorb_dynany_get_fixed_value(const rorb_dynany* d, rorb_bytes* out,
rorb_exception* exc);
rorb_status rorb_dynany_set_fixed_value(const rorb_dynany* d, const char* value, size_t len,
int32_t* out, rorb_exception* exc);
rorb_status rorb_dynany_get_as_string(const rorb_dynany* d, rorb_bytes* out,
rorb_exception* exc);
rorb_status rorb_dynany_set_as_string(const rorb_dynany* d, const char* value, size_t len,
rorb_exception* exc);
rorb_status rorb_dynany_get_as_ulong(const rorb_dynany* d, uint32_t* out, rorb_exception* exc);
rorb_status rorb_dynany_set_as_ulong(const rorb_dynany* d, uint32_t value, rorb_exception* exc);
rorb_status rorb_dynany_current_member_name(const rorb_dynany* d, rorb_bytes* out,
rorb_exception* exc);
rorb_status rorb_dynany_current_member_kind(const rorb_dynany* d, uint32_t* out,
rorb_exception* exc);
rorb_status rorb_dynany_member_count(const rorb_dynany* d, uint32_t* out, rorb_exception* exc);
rorb_status rorb_dynany_member_at(const rorb_dynany* d, uint32_t index, rorb_bytes* name,
rorb_dynany** out, rorb_exception* exc);
rorb_status rorb_dynany_set_members(const rorb_dynany* d, size_t count,
const char* const* names, const size_t* name_lens,
const rorb_any* const* values, rorb_exception* exc);
rorb_status rorb_dynany_set_members_as_dyn_any(const rorb_dynany* d, size_t count,
const char* const* names,
const size_t* name_lens,
const rorb_dynany* const* values,
rorb_exception* exc);
rorb_status rorb_dynany_get_discriminator(const rorb_dynany* d, rorb_dynany** out,
rorb_exception* exc);
rorb_status rorb_dynany_set_discriminator(const rorb_dynany* d, const rorb_dynany* disc,
rorb_exception* exc);
rorb_status rorb_dynany_set_to_default_member(const rorb_dynany* d, rorb_exception* exc);
rorb_status rorb_dynany_set_to_no_active_member(const rorb_dynany* d, rorb_exception* exc);
rorb_status rorb_dynany_has_no_active_member(const rorb_dynany* d, int32_t* out,
rorb_exception* exc);
rorb_status rorb_dynany_discriminator_kind(const rorb_dynany* d, uint32_t* out,
rorb_exception* exc);
rorb_status rorb_dynany_member(const rorb_dynany* d, rorb_dynany** out, rorb_exception* exc);
rorb_status rorb_dynany_member_name(const rorb_dynany* d, rorb_bytes* out, rorb_exception* exc);
rorb_status rorb_dynany_member_kind(const rorb_dynany* d, uint32_t* out, rorb_exception* exc);
rorb_status rorb_dynany_get_length(const rorb_dynany* d, uint32_t* out, rorb_exception* exc);
rorb_status rorb_dynany_set_length(const rorb_dynany* d, uint32_t len, rorb_exception* exc);
rorb_status rorb_dynany_element_count(const rorb_dynany* d, uint32_t* out,
rorb_exception* exc);
rorb_status rorb_dynany_element_at(const rorb_dynany* d, uint32_t index, rorb_dynany** out,
rorb_exception* exc);
rorb_status rorb_dynany_set_elements(const rorb_dynany* d, size_t count,
const rorb_any* const* values, rorb_exception* exc);
rorb_status rorb_dynany_set_elements_as_dyn_any(const rorb_dynany* d, size_t count,
const rorb_dynany* const* values,
rorb_exception* exc);
rorb_status rorb_dynany_is_null(const rorb_dynany* d, int32_t* out, rorb_exception* exc);
rorb_status rorb_dynany_set_to_null(const rorb_dynany* d, rorb_exception* exc);
rorb_status rorb_dynany_set_to_value(const rorb_dynany* d, rorb_exception* exc);
rorb_status rorb_dynany_get_boxed_value(const rorb_dynany* d, rorb_any** out,
rorb_exception* exc);
rorb_status rorb_dynany_set_boxed_value(const rorb_dynany* d, const rorb_any* value,
rorb_exception* exc);
rorb_status rorb_dynany_get_boxed_value_as_dyn_any(const rorb_dynany* d, rorb_dynany** out,
rorb_exception* exc);
rorb_status rorb_dynany_set_boxed_value_as_dyn_any(const rorb_dynany* d,
const rorb_dynany* value,
rorb_exception* exc);
rorb_status rorb_orb_init(int* argc, char** argv, rorb_orb** orb, rorb_exception* exc);
rorb_orb* rorb_orb_clone(rorb_orb* orb);
void rorb_orb_release(rorb_orb* orb);
rorb_status rorb_orb_string_to_object(rorb_orb* orb, const char* s, size_t len,
rorb_object** obj, rorb_exception* exc);
rorb_status rorb_orb_object_to_string(rorb_orb* orb, rorb_object* obj, rorb_bytes* s,
rorb_exception* exc);
rorb_status rorb_orb_resolve_initial_references(rorb_orb* orb, const char* name, size_t len,
rorb_object** obj, rorb_exception* exc);
void rorb_orb_list_initial_services(rorb_orb* orb, void* context,
void (*each)(void* context, const char* name, size_t len));
rorb_status rorb_orb_root_poa(rorb_orb* orb, rorb_poa** poa, rorb_exception* exc);
void rorb_orb_run(rorb_orb* orb);
rorb_status rorb_orb_work_pending(rorb_orb* orb, int32_t* pending, rorb_exception* exc);
rorb_status rorb_orb_perform_work(rorb_orb* orb, rorb_exception* exc);
rorb_status rorb_orb_shutdown(rorb_orb* orb, int32_t wait_for_completion, rorb_exception* exc);
rorb_status rorb_orb_destroy(rorb_orb* orb, rorb_exception* exc);
void rorb_orb_set_call_timeout(rorb_orb* orb, int64_t us);
int64_t rorb_orb_call_timeout(rorb_orb* orb);
void rorb_orb_set_connect_timeout(rorb_orb* orb, int64_t us);
int64_t rorb_orb_connect_timeout(rorb_orb* orb);
void rorb_set_thread_call_timeout(int64_t us);
int64_t rorb_thread_call_timeout(void);
rorb_status rorb_default_root_poa(rorb_poa** poa, rorb_exception* exc);
rorb_orb* rorb_default_orb(void);
#define RORB_RELATIVE_RT_TIMEOUT_POLICY_TYPE 32
#define RORB_SYNC_SCOPE_POLICY_TYPE 24
#define RORB_SET_OVERRIDE 0
#define RORB_ADD_OVERRIDE 1
typedef void (*rorb_each_policy)(void* context, uint32_t type, uint64_t value);
rorb_status rorb_orb_create_policy(rorb_orb* orb, uint32_t type, const rorb_any* value,
uint64_t* raw_value, rorb_exception* exc);
rorb_status rorb_orb_register_initial_reference(rorb_orb* orb, const char* name, size_t len,
rorb_object* obj, rorb_exception* exc);
rorb_status rorb_orb_register_local_initial_reference(rorb_orb* orb, const char* name,
size_t len, void* object,
void (*release)(void*),
rorb_exception* exc);
int32_t rorb_orb_resolve_local_initial_reference(rorb_orb* orb, const char* name, size_t len,
void* context,
void (*each)(void* context, void* object));
rorb_status rorb_orb_set_policy_overrides(rorb_orb* orb, const uint32_t* types,
const uint64_t* values, size_t count,
uint32_t set_add, rorb_exception* exc);
void rorb_orb_get_policy_overrides(rorb_orb* orb, const uint32_t* types, size_t count,
void* context, rorb_each_policy each);
rorb_status rorb_set_thread_policy_overrides(const uint32_t* types, const uint64_t* values,
size_t count, uint32_t set_add,
rorb_exception* exc);
void rorb_thread_policy_overrides(const uint32_t* types, size_t count, void* context,
rorb_each_policy each);
rorb_status rorb_object_set_policy_overrides(rorb_object* obj, const uint32_t* types,
const uint64_t* values, size_t count,
uint32_t set_add, rorb_object** result,
rorb_exception* exc);
void rorb_object_get_policy_overrides(rorb_object* obj, const uint32_t* types, size_t count,
void* context, rorb_each_policy each);
int32_t rorb_object_get_client_policy(rorb_object* obj, uint32_t type, uint64_t* raw_value);
rorb_status rorb_object_validate_connection(rorb_object* obj, int32_t* result,
rorb_exception* exc);
rorb_object* rorb_object_clone(rorb_object* obj);
void rorb_object_release(rorb_object* obj);
rorb_orb* rorb_object_orb(rorb_object* obj);
const char* rorb_object_type_id(rorb_object* obj, size_t* len);
rorb_status rorb_object_is_a(rorb_object* obj, const char* id, size_t len, int32_t* result,
rorb_exception* exc);
rorb_status rorb_object_non_existent(rorb_object* obj, int32_t* result, rorb_exception* exc);
int32_t rorb_object_is_equivalent(rorb_object* a, rorb_object* b);
uint32_t rorb_object_hash(rorb_object* obj, uint32_t maximum);
void rorb_object_set_call_timeout(rorb_object* obj, int64_t us);
int64_t rorb_object_call_timeout(rorb_object* obj);
typedef struct rorb_invocation {
const char* operation;
size_t operation_len;
int32_t oneway;
int64_t timeout_us;
void* context;
rorb_status (*write_args)(void* context, rorb_out* out);
rorb_status (*read_reply)(void* context, rorb_in* in);
rorb_status (*read_user_exception)(void* context, const char* id, size_t id_len, rorb_in* in);
} rorb_invocation;
rorb_status rorb_object_invoke(rorb_object* obj, const rorb_invocation* inv, rorb_exception* exc);
typedef void (*rorb_sendc_done_fn)(void* context, rorb_status status, const rorb_exception* exc);
rorb_status rorb_object_sendc(rorb_object* obj, const rorb_invocation* inv, rorb_sendc_done_fn done,
rorb_exception* exc);
#define RORB_PRIM_OCTET 0
#define RORB_PRIM_SHORT 1
#define RORB_PRIM_USHORT 2
#define RORB_PRIM_LONG 3
#define RORB_PRIM_ULONG 4
#define RORB_PRIM_LONGLONG 5
#define RORB_PRIM_ULONGLONG 6
#define RORB_PRIM_FLOAT 7
#define RORB_PRIM_DOUBLE 8
void rorb_out_write_boolean(rorb_out* out, int32_t v);
void rorb_out_write_octet(rorb_out* out, uint8_t v);
void rorb_out_write_char(rorb_out* out, char v);
void rorb_out_write_wchar(rorb_out* out, uint16_t v);
void rorb_out_write_short(rorb_out* out, int16_t v);
void rorb_out_write_ushort(rorb_out* out, uint16_t v);
void rorb_out_write_long(rorb_out* out, int32_t v);
void rorb_out_write_ulong(rorb_out* out, uint32_t v);
void rorb_out_write_longlong(rorb_out* out, int64_t v);
void rorb_out_write_ulonglong(rorb_out* out, uint64_t v);
void rorb_out_write_float(rorb_out* out, float v);
void rorb_out_write_double(rorb_out* out, double v);
void rorb_out_write_string(rorb_out* out, const char* s, size_t len);
void rorb_out_write_wstring(rorb_out* out, const uint16_t* s, size_t len);
void rorb_out_write_object(rorb_out* out, rorb_object* obj);
void rorb_out_write_typecode(rorb_out* out, const rorb_typecode* tc);
void rorb_out_write_any(rorb_out* out, const rorb_any* any);
void rorb_out_write_any_value(rorb_out* out, const rorb_any* any);
void rorb_out_write_longdouble(rorb_out* out, uint64_t hi, uint64_t lo);
void rorb_longdouble_from_double(double v, uint64_t* hi, uint64_t* lo);
double rorb_longdouble_to_double(uint64_t hi, uint64_t lo);
void rorb_out_write_fixed(rorb_out* out, const uint8_t* digits, size_t count, int32_t negative);
void rorb_out_write_array(rorb_out* out, int32_t kind, const void* data, size_t count);
int32_t rorb_out_failed(rorb_out* out);
int32_t rorb_in_read_boolean(rorb_in* in);
uint8_t rorb_in_read_octet(rorb_in* in);
char rorb_in_read_char(rorb_in* in);
uint16_t rorb_in_read_wchar(rorb_in* in);
int16_t rorb_in_read_short(rorb_in* in);
uint16_t rorb_in_read_ushort(rorb_in* in);
int32_t rorb_in_read_long(rorb_in* in);
uint32_t rorb_in_read_ulong(rorb_in* in);
int64_t rorb_in_read_longlong(rorb_in* in);
uint64_t rorb_in_read_ulonglong(rorb_in* in);
float rorb_in_read_float(rorb_in* in);
double rorb_in_read_double(rorb_in* in);
void rorb_in_read_longdouble(rorb_in* in, uint64_t* hi, uint64_t* lo);
const char* rorb_in_read_string(rorb_in* in, size_t* len);
const uint16_t* rorb_in_read_wstring(rorb_in* in, size_t* len);
rorb_object* rorb_in_read_object(rorb_in* in);
rorb_typecode* rorb_in_read_typecode(rorb_in* in);
rorb_any* rorb_in_read_any(rorb_in* in);
rorb_any* rorb_in_read_any_value(rorb_in* in, const rorb_typecode* tc);
void rorb_in_read_array(rorb_in* in, int32_t kind, void* data, size_t count);
int32_t rorb_in_read_fixed(rorb_in* in, uint8_t* digits, size_t count);
uint32_t rorb_in_read_length(rorb_in* in, size_t min_element_size);
void rorb_in_fail(rorb_in* in);
int32_t rorb_in_failed(rorb_in* in);
rorb_status rorb_in_error(rorb_in* in, rorb_exception* exc);
rorb_status rorb_object_invoke_stream(rorb_object* obj, const rorb_invocation* inv,
rorb_in** reply, rorb_exception* exc);
const char* rorb_in_exception_id(rorb_in* in, size_t* len);
rorb_status rorb_in_new(rorb_status (*write)(void* context, rorb_out* out), void* context,
rorb_orb* orb, rorb_in** in, rorb_exception* exc);
rorb_status rorb_cdr_encode(rorb_status (*write)(void* context, rorb_out* out), void* context,
int32_t little_endian, rorb_bytes* bytes, rorb_exception* exc);
rorb_status rorb_in_from_bytes(const uint8_t* data, size_t len, int32_t little_endian,
rorb_orb* orb, rorb_in** in, rorb_exception* exc);
rorb_status rorb_any_input(const rorb_any* any, rorb_in** in, rorb_exception* exc);
void rorb_in_release(rorb_in* in);
void rorb_out_write_null_value(rorb_out* out);
int32_t rorb_out_begin_value(rorb_out* out, uint64_t key, size_t count, const char* const* ids,
const size_t* id_lens, int32_t chunked);
void rorb_out_end_value(rorb_out* out);
#define RORB_VALUE_NULL 0
#define RORB_VALUE_INDIRECTION 1
#define RORB_VALUE_NEW 2
int32_t rorb_in_read_value_header(rorb_in* in, size_t* slot, size_t* id_count);
const char* rorb_in_value_id(rorb_in* in, size_t index, size_t* len);
void rorb_in_end_value(rorb_in* in);
void rorb_in_set_value(rorb_in* in, size_t slot, void* ptr, void (*release)(void* ptr));
void* rorb_in_get_value(rorb_in* in, size_t slot);
void rorb_register_value_type(const rorb_typecode* tc);
void rorb_set_value_type_resolver(rorb_typecode* (*resolve)(void* context, const char* id,
size_t len),
void* context);
typedef struct rorb_servant_vtable {
rorb_status (*dispatch)(void* self, const char* op, size_t op_len, rorb_in* in,
rorb_server_reply* reply);
int32_t (*is_a)(void* self, const char* id, size_t len);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_servant_vtable;
rorb_servant* rorb_servant_get(void* self, const char* repository_id, size_t len,
const rorb_servant_vtable* vtable);
void rorb_servant_release(rorb_servant* servant);
int32_t rorb_servant_current_reference(rorb_servant* servant, rorb_object** obj);
rorb_out* rorb_server_reply_output(rorb_server_reply* reply);
rorb_out* rorb_server_reply_user_exception(rorb_server_reply* reply, const char* id,
size_t len);
void rorb_server_reply_system_exception(rorb_server_reply* reply, const char* id, size_t len,
uint32_t minor, uint32_t completed);
#define RORB_ARG_IN 1
#define RORB_ARG_OUT 2
#define RORB_ARG_INOUT 3
rorb_status rorb_request_new(rorb_object* target, const char* op, size_t len,
rorb_request** request, rorb_exception* exc);
void rorb_request_release(rorb_request* request);
rorb_status rorb_request_add_arg(rorb_request* request, const char* name, size_t len,
uint32_t flags, const rorb_any* value, rorb_exception* exc);
void rorb_request_set_return_type(rorb_request* request, const rorb_typecode* tc);
void rorb_request_add_exception(rorb_request* request, const rorb_typecode* tc);
void rorb_request_set_timeout(rorb_request* request, int64_t timeout_us);
rorb_status rorb_request_invoke(rorb_request* request, rorb_exception* exc);
rorb_status rorb_request_send_oneway(rorb_request* request, rorb_exception* exc);
rorb_status rorb_request_send_deferred(rorb_request* request, rorb_exception* exc);
rorb_status rorb_request_poll_response(rorb_request* request, int32_t* ready,
rorb_exception* exc);
rorb_status rorb_request_get_response(rorb_request* request, rorb_exception* exc);
rorb_any* rorb_request_result(rorb_request* request);
rorb_any* rorb_request_argument(rorb_request* request, size_t index);
rorb_any* rorb_request_exception(rorb_request* request);
rorb_status rorb_server_request_new(rorb_in* in, const char* op, size_t len,
rorb_server_request** request, rorb_exception* exc);
void rorb_server_request_release(rorb_server_request* request);
rorb_status rorb_server_request_add_param(rorb_server_request* request, const char* name,
size_t len, uint32_t flags, const rorb_typecode* tc,
rorb_exception* exc);
rorb_status rorb_server_request_arguments(rorb_server_request* request, rorb_exception* exc);
rorb_any* rorb_server_request_argument(rorb_server_request* request, size_t index);
rorb_status rorb_server_request_set_argument(rorb_server_request* request, size_t index,
const rorb_any* value, rorb_exception* exc);
rorb_status rorb_server_request_set_result(rorb_server_request* request, const rorb_any* value,
rorb_exception* exc);
rorb_status rorb_server_request_set_exception(rorb_server_request* request,
const rorb_any* value, rorb_exception* exc);
rorb_status rorb_server_request_reply(rorb_server_request* request, rorb_server_reply* reply,
rorb_exception* exc);
#define RORB_THREAD_POLICY_ID 16
#define RORB_LIFESPAN_POLICY_ID 17
#define RORB_ID_UNIQUENESS_POLICY_ID 18
#define RORB_ID_ASSIGNMENT_POLICY_ID 19
#define RORB_IMPLICIT_ACTIVATION_POLICY_ID 20
#define RORB_SERVANT_RETENTION_POLICY_ID 21
#define RORB_REQUEST_PROCESSING_POLICY_ID 22
#define RORB_BIDIRECTIONAL_POLICY_TYPE 37
typedef struct rorb_policy {
uint32_t type;
uint32_t value;
} rorb_policy;
rorb_poa* rorb_poa_clone(rorb_poa* poa);
void rorb_poa_release(rorb_poa* poa);
const char* rorb_poa_name(rorb_poa* poa, size_t* len);
rorb_poa* rorb_poa_parent(rorb_poa* poa);
void rorb_poa_children(rorb_poa* poa, void* context, void (*each)(void* context, rorb_poa* child));
rorb_poa_manager* rorb_poa_the_manager(rorb_poa* poa);
void rorb_poa_policies(rorb_poa* poa, rorb_policy policies[7]);
rorb_status rorb_poa_create_poa(rorb_poa* poa, const char* name, size_t len,
rorb_poa_manager* manager, const rorb_policy* policies,
size_t count, rorb_poa** child, rorb_exception* exc);
rorb_status rorb_poa_find_poa(rorb_poa* poa, const char* name, size_t len, int32_t activate_it,
rorb_poa** child, rorb_exception* exc);
rorb_status rorb_poa_destroy(rorb_poa* poa, int32_t etherealize, int32_t wait_for_completion,
rorb_exception* exc);
rorb_status rorb_poa_activate_object(rorb_poa* poa, rorb_servant* servant, rorb_bytes* id,
rorb_exception* exc);
rorb_status rorb_poa_activate_object_with_id(rorb_poa* poa, const uint8_t* id, size_t len,
rorb_servant* servant, rorb_exception* exc);
rorb_status rorb_poa_deactivate_object(rorb_poa* poa, const uint8_t* id, size_t len,
rorb_exception* exc);
rorb_status rorb_poa_servant_to_id(rorb_poa* poa, rorb_servant* servant, rorb_bytes* id,
rorb_exception* exc);
rorb_status rorb_poa_servant_to_reference(rorb_poa* poa, rorb_servant* servant,
rorb_object** obj, rorb_exception* exc);
rorb_status rorb_poa_id_to_servant(rorb_poa* poa, const uint8_t* id, size_t len, void** self,
rorb_exception* exc);
rorb_status rorb_poa_id_to_reference(rorb_poa* poa, const uint8_t* id, size_t len,
rorb_object** obj, rorb_exception* exc);
rorb_status rorb_poa_reference_to_id(rorb_poa* poa, rorb_object* obj, rorb_bytes* id,
rorb_exception* exc);
rorb_status rorb_poa_reference_to_servant(rorb_poa* poa, rorb_object* obj, void** self,
rorb_exception* exc);
rorb_status rorb_poa_create_reference(rorb_poa* poa, const char* intf, size_t len,
rorb_object** obj, rorb_exception* exc);
rorb_status rorb_poa_create_reference_with_id(rorb_poa* poa, const uint8_t* id, size_t id_len,
const char* intf, size_t len, rorb_object** obj,
rorb_exception* exc);
rorb_status rorb_poa_get_servant(rorb_poa* poa, void** self, rorb_exception* exc);
rorb_status rorb_poa_set_servant(rorb_poa* poa, rorb_servant* servant, rorb_exception* exc);
typedef struct rorb_manager_error rorb_manager_error;
void rorb_manager_error_forward(rorb_manager_error* error, rorb_object* obj);
void rorb_manager_error_system(rorb_manager_error* error, const char* id, size_t len,
uint32_t minor, uint32_t completed);
typedef struct rorb_servant_activator_vtable {
rorb_status (*incarnate)(void* self, const uint8_t* id, size_t id_len, rorb_poa* adapter,
rorb_servant** servant, rorb_manager_error* error);
void (*etherealize)(void* self, const uint8_t* id, size_t id_len, rorb_poa* adapter,
void* servant, int32_t cleanup_in_progress,
int32_t remaining_activations);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_servant_activator_vtable;
typedef struct rorb_servant_locator_vtable {
rorb_status (*preinvoke)(void* self, const uint8_t* id, size_t id_len, rorb_poa* adapter,
const char* op, size_t op_len, rorb_servant** servant, void** cookie,
rorb_manager_error* error);
void (*postinvoke)(void* self, const uint8_t* id, size_t id_len, rorb_poa* adapter,
const char* op, size_t op_len, void* cookie, void* servant);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_servant_locator_vtable;
typedef struct rorb_adapter_activator_vtable {
int32_t (*unknown_adapter)(void* self, rorb_poa* parent, const char* name, size_t len);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_adapter_activator_vtable;
#define RORB_NO_SERVANT_MANAGER 0
#define RORB_SERVANT_ACTIVATOR 1
#define RORB_SERVANT_LOCATOR 2
rorb_status rorb_poa_set_servant_activator(rorb_poa* poa, void* self,
const rorb_servant_activator_vtable* vtable,
rorb_exception* exc);
rorb_status rorb_poa_set_servant_locator(rorb_poa* poa, void* self,
const rorb_servant_locator_vtable* vtable,
rorb_exception* exc);
rorb_status rorb_poa_get_servant_manager(rorb_poa* poa, int32_t* kind, void** self,
rorb_exception* exc);
rorb_status rorb_poa_set_the_activator(rorb_poa* poa, void* self,
const rorb_adapter_activator_vtable* vtable,
rorb_exception* exc);
void* rorb_poa_the_activator(rorb_poa* poa);
rorb_status rorb_current_get_poa(rorb_poa** poa, rorb_exception* exc);
rorb_status rorb_current_get_object_id(rorb_bytes* id, rorb_exception* exc);
rorb_status rorb_current_get_reference(rorb_object** obj, rorb_exception* exc);
rorb_status rorb_current_get_servant(void** self, rorb_exception* exc);
#define RORB_POA_MANAGER_HOLDING 0
#define RORB_POA_MANAGER_ACTIVE 1
#define RORB_POA_MANAGER_DISCARDING 2
#define RORB_POA_MANAGER_INACTIVE 3
rorb_poa_manager* rorb_poa_manager_clone(rorb_poa_manager* manager);
void rorb_poa_manager_release(rorb_poa_manager* manager);
uint32_t rorb_poa_manager_get_state(rorb_poa_manager* manager);
rorb_status rorb_poa_manager_activate(rorb_poa_manager* manager, rorb_exception* exc);
rorb_status rorb_poa_manager_hold_requests(rorb_poa_manager* manager,
int32_t wait_for_completion, rorb_exception* exc);
rorb_status rorb_poa_manager_discard_requests(rorb_poa_manager* manager,
int32_t wait_for_completion, rorb_exception* exc);
rorb_status rorb_poa_manager_deactivate(rorb_poa_manager* manager, int32_t etherealize,
int32_t wait_for_completion, rorb_exception* exc);
const char* rorb_poa_manager_get_id(rorb_poa_manager* manager, size_t* len);
int32_t rorb_poa_manager_equal(rorb_poa_manager* a, rorb_poa_manager* b);
rorb_status rorb_poa_create_poa_manager(rorb_poa* poa, const char* id, size_t id_len,
const uint32_t* types, const uint64_t* values,
size_t count, rorb_poa_manager** manager,
rorb_exception* exc);
void rorb_poa_list_poa_managers(rorb_poa* poa, void* context,
void (*each)(void* context, rorb_poa_manager* manager));
rorb_status rorb_poa_find_poa_manager(rorb_poa* poa, const char* id, size_t id_len,
rorb_poa_manager** manager, rorb_exception* exc);
typedef struct rorb_pi_error rorb_pi_error;
typedef struct rorb_client_request_info rorb_client_request_info;
typedef struct rorb_server_request_info rorb_server_request_info;
typedef struct rorb_ior_info rorb_ior_info;
typedef struct rorb_orb_init_info rorb_orb_init_info;
typedef struct rorb_pi_current rorb_pi_current;
typedef struct rorb_codec rorb_codec;
void rorb_pi_error_forward(rorb_pi_error* error, rorb_object* obj);
void rorb_pi_error_system(rorb_pi_error* error, const char* id, size_t len, uint32_t minor,
uint32_t completed);
typedef struct rorb_client_interceptor_vtable {
rorb_status (*send_request)(void* self, const rorb_client_request_info* ri,
rorb_pi_error* error);
rorb_status (*receive_reply)(void* self, const rorb_client_request_info* ri,
rorb_pi_error* error);
rorb_status (*receive_exception)(void* self, const rorb_client_request_info* ri,
rorb_pi_error* error);
rorb_status (*receive_other)(void* self, const rorb_client_request_info* ri,
rorb_pi_error* error);
void (*destroy)(void* self);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_client_interceptor_vtable;
typedef struct rorb_server_interceptor_vtable {
rorb_status (*receive_request_service_contexts)(void* self, const rorb_server_request_info* ri,
rorb_pi_error* error);
rorb_status (*receive_request)(void* self, const rorb_server_request_info* ri,
rorb_pi_error* error);
rorb_status (*send_reply)(void* self, const rorb_server_request_info* ri,
rorb_pi_error* error);
rorb_status (*send_exception)(void* self, const rorb_server_request_info* ri,
rorb_pi_error* error);
rorb_status (*send_other)(void* self, const rorb_server_request_info* ri,
rorb_pi_error* error);
void (*destroy)(void* self);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_server_interceptor_vtable;
typedef struct rorb_ior_interceptor_vtable {
rorb_status (*establish_components)(void* self, const rorb_ior_info* info,
rorb_pi_error* error);
void (*destroy)(void* self);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_ior_interceptor_vtable;
typedef struct rorb_orb_initializer_vtable {
rorb_status (*pre_init)(void* self, rorb_orb_init_info* info, rorb_pi_error* error);
rorb_status (*post_init)(void* self, rorb_orb_init_info* info, rorb_pi_error* error);
void (*add_ref)(void* self);
void (*remove_ref)(void* self);
} rorb_orb_initializer_vtable;
typedef struct rorb_orb_initializer {
void* self;
const rorb_orb_initializer_vtable* vtable;
} rorb_orb_initializer;
void rorb_register_orb_initializer(void* self, const rorb_orb_initializer_vtable* vtable);
rorb_status rorb_orb_init_pi(int* argc, char** argv, const char* orb_id, size_t orb_id_len,
const rorb_orb_initializer* initializers, size_t count,
rorb_orb** orb, rorb_exception* exc);
typedef void (*rorb_each_string)(void* context, const char* s, size_t len);
typedef void (*rorb_each_component)(void* context, uint32_t tag, const uint8_t* data,
size_t len);
typedef void (*rorb_each_parameter)(void* context, rorb_any* argument, uint32_t mode);
typedef void (*rorb_each_typecode)(void* context, rorb_typecode* tc);
#define RORB_PI_SUCCESSFUL 0
#define RORB_PI_SYSTEM_EXCEPTION 1
#define RORB_PI_USER_EXCEPTION 2
#define RORB_PI_LOCATION_FORWARD 3
#define RORB_PI_TRANSPORT_RETRY 4
#define RORB_PI_UNKNOWN 5
uint32_t rorb_cri_request_id(const rorb_client_request_info* ri);
const char* rorb_cri_operation(const rorb_client_request_info* ri, size_t* len);
int32_t rorb_cri_response_expected(const rorb_client_request_info* ri);
int16_t rorb_cri_sync_scope(const rorb_client_request_info* ri);
rorb_status rorb_cri_reply_status(const rorb_client_request_info* ri, int16_t* status,
rorb_exception* exc);
rorb_status rorb_cri_forward_reference(const rorb_client_request_info* ri, rorb_object** obj,
rorb_exception* exc);
rorb_status rorb_cri_get_slot(const rorb_client_request_info* ri, uint32_t id, rorb_any** any,
rorb_exception* exc);
rorb_status rorb_cri_get_request_service_context(const rorb_client_request_info* ri,
uint32_t id, rorb_bytes* data,
rorb_exception* exc);
rorb_status rorb_cri_get_reply_service_context(const rorb_client_request_info* ri, uint32_t id,
rorb_bytes* data, rorb_exception* exc);
rorb_status rorb_cri_arguments(const rorb_client_request_info* ri, void* context,
rorb_each_parameter each, rorb_exception* exc);
rorb_status rorb_cri_exceptions(const rorb_client_request_info* ri, void* context,
rorb_each_typecode each, rorb_exception* exc);
rorb_status rorb_cri_result(const rorb_client_request_info* ri, rorb_any** any,
rorb_exception* exc);
rorb_object* rorb_cri_target(const rorb_client_request_info* ri);
rorb_object* rorb_cri_effective_target(const rorb_client_request_info* ri);
uint32_t rorb_cri_effective_profile(const rorb_client_request_info* ri, rorb_bytes* data);
rorb_status rorb_cri_received_exception(const rorb_client_request_info* ri, rorb_any** any,
rorb_exception* exc);
rorb_status rorb_cri_received_exception_id(const rorb_client_request_info* ri, rorb_bytes* id,
rorb_exception* exc);
rorb_status rorb_cri_get_effective_component(const rorb_client_request_info* ri, uint32_t tag,
rorb_bytes* data, rorb_exception* exc);
rorb_status rorb_cri_get_effective_components(const rorb_client_request_info* ri, uint32_t tag,
void* context, rorb_each_component each,
rorb_exception* exc);
rorb_status rorb_cri_get_request_policy(const rorb_client_request_info* ri, uint32_t type,
int32_t* found, uint64_t* raw_value,
rorb_exception* exc);
rorb_status rorb_cri_add_request_service_context(const rorb_client_request_info* ri,
uint32_t id, const uint8_t* data, size_t len,
int32_t replace, rorb_exception* exc);
uint32_t rorb_sri_request_id(const rorb_server_request_info* ri);
const char* rorb_sri_operation(const rorb_server_request_info* ri, size_t* len);
int32_t rorb_sri_response_expected(const rorb_server_request_info* ri);
int16_t rorb_sri_sync_scope(const rorb_server_request_info* ri);
rorb_status rorb_sri_reply_status(const rorb_server_request_info* ri, int16_t* status,
rorb_exception* exc);
rorb_status rorb_sri_forward_reference(const rorb_server_request_info* ri, rorb_object** obj,
rorb_exception* exc);
rorb_status rorb_sri_get_slot(const rorb_server_request_info* ri, uint32_t id, rorb_any** any,
rorb_exception* exc);
rorb_status rorb_sri_set_slot(const rorb_server_request_info* ri, uint32_t id,
const rorb_any* any, rorb_exception* exc);
rorb_status rorb_sri_get_request_service_context(const rorb_server_request_info* ri,
uint32_t id, rorb_bytes* data,
rorb_exception* exc);
rorb_status rorb_sri_get_reply_service_context(const rorb_server_request_info* ri, uint32_t id,
rorb_bytes* data, rorb_exception* exc);
rorb_status rorb_sri_add_reply_service_context(const rorb_server_request_info* ri, uint32_t id,
const uint8_t* data, size_t len,
int32_t replace, rorb_exception* exc);
rorb_status rorb_sri_arguments(const rorb_server_request_info* ri, void* context,
rorb_each_parameter each, rorb_exception* exc);
rorb_status rorb_sri_exceptions(const rorb_server_request_info* ri, void* context,
rorb_each_typecode each, rorb_exception* exc);
rorb_status rorb_sri_result(const rorb_server_request_info* ri, rorb_any** any,
rorb_exception* exc);
rorb_status rorb_sri_sending_exception(const rorb_server_request_info* ri, rorb_any** any,
rorb_exception* exc);
rorb_status rorb_sri_sending_exception_id(const rorb_server_request_info* ri, rorb_bytes* id,
rorb_exception* exc);
rorb_status rorb_sri_object_id(const rorb_server_request_info* ri, rorb_bytes* id,
rorb_exception* exc);
rorb_status rorb_sri_adapter_id(const rorb_server_request_info* ri, rorb_bytes* id,
rorb_exception* exc);
rorb_status rorb_sri_adapter_name(const rorb_server_request_info* ri, void* context,
rorb_each_string each, rorb_exception* exc);
const char* rorb_sri_orb_id(const rorb_server_request_info* ri, size_t* len);
const char* rorb_sri_server_id(const rorb_server_request_info* ri, size_t* len);
rorb_status rorb_sri_target_most_derived_interface(const rorb_server_request_info* ri,
rorb_bytes* id, rorb_exception* exc);
rorb_status rorb_sri_target_is_a(const rorb_server_request_info* ri, const char* id, size_t len,
int32_t* is_a, rorb_exception* exc);
rorb_status rorb_sri_get_server_policy(const rorb_server_request_info* ri, uint32_t type,
uint64_t* raw_value, rorb_exception* exc);
rorb_status rorb_ior_info_get_effective_policy(const rorb_ior_info* info, uint32_t type,
uint64_t* raw_value, rorb_exception* exc);
void rorb_ior_info_adapter_name(const rorb_ior_info* info, void* context, rorb_each_string each);
void rorb_ior_info_add_ior_component(const rorb_ior_info* info, uint32_t tag,
const uint8_t* data, size_t len);
rorb_status rorb_ior_info_add_ior_component_to_profile(const rorb_ior_info* info, uint32_t tag,
const uint8_t* data, size_t len,
uint32_t profile_id,
rorb_exception* exc);
void rorb_init_info_arguments(const rorb_orb_init_info* info, void* context,
rorb_each_string each);
const char* rorb_init_info_orb_id(const rorb_orb_init_info* info, size_t* len);
rorb_orb* rorb_init_info_orb(const rorb_orb_init_info* info);
rorb_status rorb_init_info_register_initial_reference(const rorb_orb_init_info* info,
const char* name, size_t len,
rorb_object* obj, rorb_exception* exc);
rorb_status rorb_init_info_resolve_initial_references(const rorb_orb_init_info* info,
const char* name, size_t len,
rorb_object** obj, rorb_exception* exc);
rorb_status rorb_init_info_add_client_request_interceptor(
rorb_orb_init_info* info, const char* name, size_t len, void* self,
const rorb_client_interceptor_vtable* vtable, rorb_exception* exc);
rorb_status rorb_init_info_add_server_request_interceptor(
rorb_orb_init_info* info, const char* name, size_t len, void* self,
const rorb_server_interceptor_vtable* vtable, rorb_exception* exc);
rorb_status rorb_init_info_add_ior_interceptor(rorb_orb_init_info* info, const char* name,
size_t len, void* self,
const rorb_ior_interceptor_vtable* vtable,
rorb_exception* exc);
uint32_t rorb_init_info_allocate_slot_id(rorb_orb_init_info* info);
rorb_pi_current* rorb_init_info_pi_current(const rorb_orb_init_info* info);
rorb_status rorb_init_info_create_codec(const rorb_orb_init_info* info, int16_t format,
uint8_t major, uint8_t minor, rorb_codec** codec,
rorb_exception* exc);
rorb_pi_current* rorb_orb_pi_current(rorb_orb* orb);
void rorb_pi_current_release(rorb_pi_current* current);
rorb_status rorb_pi_current_get_slot(const rorb_pi_current* current, uint32_t id,
rorb_any** any, rorb_exception* exc);
rorb_status rorb_pi_current_set_slot(const rorb_pi_current* current, uint32_t id,
const rorb_any* any, rorb_exception* exc);
#define RORB_ENCODING_CDR_ENCAPS 0
rorb_status rorb_orb_create_codec(rorb_orb* orb, int16_t format, uint8_t major, uint8_t minor,
rorb_codec** codec, rorb_exception* exc);
void rorb_codec_release(rorb_codec* codec);
rorb_status rorb_codec_encode(const rorb_codec* codec, const rorb_any* any, int32_t value_only,
rorb_bytes* data, rorb_exception* exc);
rorb_status rorb_codec_decode(const rorb_codec* codec, const uint8_t* data, size_t len,
const rorb_typecode* tc, rorb_any** any, rorb_exception* exc);
#ifdef __cplusplus
}
#endif
#endif