## orbit2-small

orbit2-small —

## Synopsis

    struct      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);
    struct      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);
    struct      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

### struct ORBit_IModule

    struct ORBit_IModule {

    	CORBA_unsigned_long           version;
    	ORBit_IInterface            **interfaces;
    	CORBA_sequence_CORBA_TypeCode types;
    };

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

### struct ORBitConnection

    struct 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 : |

### struct ORBitAsyncQueueEntry

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