orbit2-small

orbit2-small —

Synopsis




            ORBit_IModule;
const char* ORBit_get_safe_tmp              (void);
gpointer    ORBit_small_alloc               (CORBA_TypeCode tc);
gpointer    ORBit_small_allocbuf            (CORBA_TypeCode tc,
                                             CORBA_unsigned_long length);
void        ORBit_small_freekids            (CORBA_TypeCode tc,
                                             gpointer p,
                                             gpointer d);
gpointer    ORBit_sequence_alloc            (CORBA_TypeCode sequence_tc,
                                             CORBA_unsigned_long length);
void        ORBit_sequence_append           (gpointer sequence,
                                             gconstpointer element);
void        ORBit_sequence_set_size         (gpointer sequence,
                                             CORBA_unsigned_long length);
#define     ORBit_sequence_index            (sequence,idx)
void        ORBit_sequence_concat           (gpointer sequence,
                                             gconstpointer append);
enum        ORBitConnectionStatus;
gpointer    ORBit_small_get_servant         (CORBA_Object obj);
ORBitConnectionStatus ORBit_small_get_connection_status
                                            (CORBA_Object obj);
ORBitConnectionStatus ORBit_small_listen_for_broken
                                            (CORBA_Object obj,
                                             GCallback fn,
                                             gpointer user_data);
ORBitConnectionStatus ORBit_small_unlisten_for_broken_full
                                            (CORBA_Object obj,
                                             GCallback fn,
                                             gpointer user_data);
ORBitConnectionStatus ORBit_small_unlisten_for_broken
                                            (CORBA_Object obj,
                                             GCallback fn);
            ORBitConnection;
ORBitConnection* ORBit_small_get_connection (CORBA_Object obj);
ORBitConnection* ORBit_small_get_connection_ref
                                            (CORBA_Object obj);
void        ORBit_small_connection_unref    (ORBitConnection *cnx);
void        ORBit_connection_set_max_buffer (ORBitConnection *cnx,
                                             gulong max_buffer_bytes);
ORBit_IInterface* ORBit_small_get_iinterface
                                            (CORBA_Object opt_object,
                                             const CORBA_char *repo_id,
                                             CORBA_Environment *ev);
extern      int     ORBit_small_flags;
CORBA_sequence_ORBit_IInterface* ORBit_small_get_iinterfaces
                                            (const char *name);
            ORBitAsyncQueueEntry;
void        ORBit_small_invoke_stub_n       (CORBA_Object object,
                                             ORBit_IMethods *methods,
                                             glong index,
                                             gpointer ret,
                                             gpointer *args,
                                             CORBA_Context ctx,
                                             CORBA_Environment *ev);
CORBA_char* ORBit_small_get_type_id         (CORBA_Object object,
                                             CORBA_Environment *ev);
void        (*ORBitAsyncInvokeFunc)         (CORBA_Object object,
                                             ORBit_IMethod *m_data,
                                             ORBitAsyncQueueEntry *aqe,
                                             gpointer user_data,
                                             CORBA_Environment *ev);
void        ORBit_small_demarshal_async     (ORBitAsyncQueueEntry *aqe,
                                             gpointer ret,
                                             gpointer *args,
                                             CORBA_Environment *ev);
void        ORBit_small_invoke_stub         (CORBA_Object object,
                                             ORBit_IMethod *m_data,
                                             gpointer ret,
                                             gpointer *args,
                                             CORBA_Context ctx,
                                             CORBA_Environment *ev);
void        ORBit_small_invoke_async        (CORBA_Object obj,
                                             ORBit_IMethod *m_data,
                                             ORBitAsyncInvokeFunc fn,
                                             gpointer user_data,
                                             gpointer *args,
                                             CORBA_Context ctx,
                                             CORBA_Environment *ev);
#define     ORBIT_SMALL_FAST_LOCALS
#define     ORBIT_SMALL_FORCE_GENERIC_MARSHAL
CORBA_sequence_CORBA_TypeCode* ORBit_small_get_types
                                            (const char *name);
gboolean    ORBit_small_load_typelib        (const char *libname);

Description

Details

ORBit_IModule

typedef struct {
	CORBA_unsigned_long           version;
	ORBit_IInterface            **interfaces;
	CORBA_sequence_CORBA_TypeCode types;
} ORBit_IModule;


ORBit_get_safe_tmp ()

const char* ORBit_get_safe_tmp              (void);

Returns :

ORBit_small_alloc ()

gpointer    ORBit_small_alloc               (CORBA_TypeCode tc);

tc :
Returns :

ORBit_small_allocbuf ()

gpointer    ORBit_small_allocbuf            (CORBA_TypeCode tc,
                                             CORBA_unsigned_long length);

tc :
length :
Returns :

ORBit_small_freekids ()

void        ORBit_small_freekids            (CORBA_TypeCode tc,
                                             gpointer p,
                                             gpointer d);

tc :
p :
d :

ORBit_sequence_alloc ()

gpointer    ORBit_sequence_alloc            (CORBA_TypeCode sequence_tc,
                                             CORBA_unsigned_long length);

sequence_tc :
length :
Returns :

ORBit_sequence_append ()

void        ORBit_sequence_append           (gpointer sequence,
                                             gconstpointer element);

sequence :
element :

ORBit_sequence_set_size ()

void        ORBit_sequence_set_size         (gpointer sequence,
                                             CORBA_unsigned_long length);

sequence :
length :

ORBit_sequence_index()

#define        ORBit_sequence_index(sequence,idx) (sequence)->_buffer[(idx)]

sequence :
idx :

ORBit_sequence_concat ()

void        ORBit_sequence_concat           (gpointer sequence,
                                             gconstpointer append);

sequence :
append :

enum ORBitConnectionStatus

typedef enum {
	ORBIT_CONNECTION_CONNECTED,
	ORBIT_CONNECTION_CONNECTING,
	ORBIT_CONNECTION_DISCONNECTED,
	ORBIT_CONNECTION_IN_PROC
} ORBitConnectionStatus;


ORBit_small_get_servant ()

gpointer    ORBit_small_get_servant         (CORBA_Object obj);

obj :
Returns :

ORBit_small_get_connection_status ()

ORBitConnectionStatus ORBit_small_get_connection_status
                                            (CORBA_Object obj);

obj :
Returns :

ORBit_small_listen_for_broken ()

ORBitConnectionStatus ORBit_small_listen_for_broken
                                            (CORBA_Object obj,
                                             GCallback fn,
                                             gpointer user_data);

obj :
fn :
user_data :
Returns :

ORBit_small_unlisten_for_broken_full ()

ORBitConnectionStatus ORBit_small_unlisten_for_broken_full
                                            (CORBA_Object obj,
                                             GCallback fn,
                                             gpointer user_data);

obj :
fn :
user_data :
Returns :

ORBit_small_unlisten_for_broken ()

ORBitConnectionStatus ORBit_small_unlisten_for_broken
                                            (CORBA_Object obj,
                                             GCallback fn);

obj :
fn :
Returns :

ORBitConnection

typedef struct _ORBitConnection ORBitConnection;


ORBit_small_get_connection ()

ORBitConnection* ORBit_small_get_connection (CORBA_Object obj);

obj :
Returns :

ORBit_small_get_connection_ref ()

ORBitConnection* ORBit_small_get_connection_ref
                                            (CORBA_Object obj);

obj :
Returns :

ORBit_small_connection_unref ()

void        ORBit_small_connection_unref    (ORBitConnection *cnx);

cnx :

ORBit_connection_set_max_buffer ()

void        ORBit_connection_set_max_buffer (ORBitConnection *cnx,
                                             gulong max_buffer_bytes);

cnx :
max_buffer_bytes :

ORBit_small_get_iinterface ()

ORBit_IInterface* ORBit_small_get_iinterface
                                            (CORBA_Object opt_object,
                                             const CORBA_char *repo_id,
                                             CORBA_Environment *ev);

opt_object :
repo_id :
ev :
Returns :

ORBit_small_flags

extern int     ORBit_small_flags;


ORBit_small_get_iinterfaces ()

CORBA_sequence_ORBit_IInterface* ORBit_small_get_iinterfaces
                                            (const char *name);

name :
Returns :

ORBitAsyncQueueEntry

typedef struct _ORBitAsyncQueueEntry ORBitAsyncQueueEntry;


ORBit_small_invoke_stub_n ()

void        ORBit_small_invoke_stub_n       (CORBA_Object object,
                                             ORBit_IMethods *methods,
                                             glong index,
                                             gpointer ret,
                                             gpointer *args,
                                             CORBA_Context ctx,
                                             CORBA_Environment *ev);

object :
methods :
index :
ret :
args :
ctx :
ev :

ORBit_small_get_type_id ()

CORBA_char* ORBit_small_get_type_id         (CORBA_Object object,
                                             CORBA_Environment *ev);

object :
ev :
Returns :

ORBitAsyncInvokeFunc ()

void        (*ORBitAsyncInvokeFunc)         (CORBA_Object object,
                                             ORBit_IMethod *m_data,
                                             ORBitAsyncQueueEntry *aqe,
                                             gpointer user_data,
                                             CORBA_Environment *ev);

object :
m_data :
aqe :
user_data :
ev :

ORBit_small_demarshal_async ()

void        ORBit_small_demarshal_async     (ORBitAsyncQueueEntry *aqe,
                                             gpointer ret,
                                             gpointer *args,
                                             CORBA_Environment *ev);

aqe :
ret :
args :
ev :

ORBit_small_invoke_stub ()

void        ORBit_small_invoke_stub         (CORBA_Object object,
                                             ORBit_IMethod *m_data,
                                             gpointer ret,
                                             gpointer *args,
                                             CORBA_Context ctx,
                                             CORBA_Environment *ev);

object :
m_data :
ret :
args :
ctx :
ev :

ORBit_small_invoke_async ()

void        ORBit_small_invoke_async        (CORBA_Object obj,
                                             ORBit_IMethod *m_data,
                                             ORBitAsyncInvokeFunc fn,
                                             gpointer user_data,
                                             gpointer *args,
                                             CORBA_Context ctx,
                                             CORBA_Environment *ev);

This method is used to invoke a remote (or local) method asynchronously. fn is called back on return - either with an empty CORBA_Environment indicating success, or with the error.

obj :
m_data :
fn :
user_data :
args :
ctx :
ev :

ORBIT_SMALL_FAST_LOCALS

#define ORBIT_SMALL_FAST_LOCALS           1


ORBIT_SMALL_FORCE_GENERIC_MARSHAL

#define ORBIT_SMALL_FORCE_GENERIC_MARSHAL 2


ORBit_small_get_types ()

CORBA_sequence_CORBA_TypeCode* ORBit_small_get_types
                                            (const char *name);

name :
Returns :

ORBit_small_load_typelib ()

gboolean    ORBit_small_load_typelib        (const char *libname);

This method has security issues if you do not use an absolute path in libname. The environment variables ORBIT_TYPELIB_PATH and GNOME2_PATH are used to scan for type libraries.

libname : the name of the type library to load
Returns : FALSE if load failed.