## 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.

### 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.