<MACRO>
<NAME>G_BEGIN_DECLS</NAME>
#    define G_BEGIN_DECLS extern "C" {
</MACRO>
<MACRO>
<NAME>G_END_DECLS</NAME>
#    define G_END_DECLS }
</MACRO>
<MACRO>
<NAME>G_BEGIN_DECLS</NAME>
#    define G_BEGIN_DECLS
</MACRO>
<MACRO>
<NAME>G_END_DECLS</NAME>
#    define G_END_DECLS
</MACRO>
<MACRO>
<NAME>GDA_CONFIG_SECTION_DATASOURCES</NAME>
#define GDA_CONFIG_SECTION_DATASOURCES       "/apps/gda/Datasources"
</MACRO>
<MACRO>
<NAME>GDA_CONFIG_SECTION_LAST_CONNECTIONS</NAME>
#define GDA_CONFIG_SECTION_LAST_CONNECTIONS  "/apps/gda/LastConnections"
</MACRO>
<MACRO>
<NAME>GDA_CONFIG_SECTION_LOG</NAME>
#define GDA_CONFIG_SECTION_LOG               "/apps/gda/Log"
</MACRO>
<MACRO>
<NAME>GDA_CONFIG_KEY_MAX_LAST_CONNECTIONS</NAME>
#define GDA_CONFIG_KEY_MAX_LAST_CONNECTIONS  "/apps/gda/MaxLastConnections"
</MACRO>
<FUNCTION>
<NAME>gda_config_get_string</NAME>
<RETURNS>gchar *</RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_int</NAME>
<RETURNS>gint </RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_float</NAME>
<RETURNS>gdouble </RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_boolean</NAME>
<RETURNS>gboolean </RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_string</NAME>
<RETURNS>void </RETURNS>
const gchar * path,const gchar * new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_int</NAME>
<RETURNS>void </RETURNS>
const gchar * path, gint new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_float</NAME>
<RETURNS>void </RETURNS>
const gchar * path, gdouble new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_boolean</NAME>
<RETURNS>void </RETURNS>
const gchar * path, gboolean new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_remove_section</NAME>
<RETURNS>void </RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_remove_key</NAME>
<RETURNS>void </RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_has_section</NAME>
<RETURNS>gboolean </RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_has_key</NAME>
<RETURNS>gboolean </RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_commit</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_config_rollback</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_config_list_sections</NAME>
<RETURNS>GList *</RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_list_keys</NAME>
<RETURNS>GList *</RETURNS>
const gchar * path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_free_list</NAME>
<RETURNS>void </RETURNS>
GList * list
</FUNCTION>
<STRUCT>
<NAME>GdaProvider</NAME>
typedef struct _GdaProvider {
	gchar *name;
	gchar *comment;
	gchar *location;
	gchar *repo_id;
	gchar *type;
	gchar *username;
	gchar *hostname;
	gchar *domain;
	GList *dsn_params;
} GdaProvider;
</STRUCT>
<MACRO>
<NAME>GDA_PROVIDER_TYPE</NAME>
#define GDA_PROVIDER_TYPE(srv)       ((srv) ? (srv)->type : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_NAME</NAME>
#define GDA_PROVIDER_NAME(srv)       ((srv) ? (srv)->name : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_COMMENT</NAME>
#define GDA_PROVIDER_COMMENT(srv)    ((srv) ? (srv)->comment : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_LOCATION</NAME>
#define GDA_PROVIDER_LOCATION(srv)   ((srv) ? (srv)->location : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_REPO_ID</NAME>
#define GDA_PROVIDER_REPO_ID(srv)    ((srv) ? (srv)->repo_id : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_USERNAME</NAME>
#define GDA_PROVIDER_USERNAME(srv)   ((srv) ? (srv)->username : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_HOSTNAME</NAME>
#define GDA_PROVIDER_HOSTNAME(srv)   ((srv) ? (srv)->hostname : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_DOMAIN</NAME>
#define GDA_PROVIDER_DOMAIN(srv)     ((srv) ? (srv)->domain : NULL)
</MACRO>
<MACRO>
<NAME>GDA_PROVIDER_DSN_PARAMS</NAME>
#define GDA_PROVIDER_DSN_PARAMS(srv) ((srv) ? (srv)->dsn_params : NULL)
</MACRO>
<FUNCTION>
<NAME>gda_provider_new</NAME>
<RETURNS>GdaProvider *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_provider_copy</NAME>
<RETURNS>GdaProvider *</RETURNS>
GdaProvider * provider
</FUNCTION>
<FUNCTION>
<NAME>gda_provider_free</NAME>
<RETURNS>void </RETURNS>
GdaProvider * provider
</FUNCTION>
<FUNCTION>
<NAME>gda_provider_list</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_provider_free_list</NAME>
<RETURNS>void </RETURNS>
GList * list
</FUNCTION>
<FUNCTION>
<NAME>gda_provider_find_by_name</NAME>
<RETURNS>GdaProvider *</RETURNS>
const gchar * name
</FUNCTION>
<FUNCTION>
<NAME>gda_list_datasources</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_list_datasources_for_provider</NAME>
<RETURNS>GList *</RETURNS>
gchar * name
</FUNCTION>
<STRUCT>
<NAME>GdaDsn</NAME>
typedef struct _GdaDsn {
	gchar *gda_name;
	gchar *provider;
	gchar *dsn_str;
	gchar *description;
	gchar *username;
	gchar *config;
	gboolean is_global;
} GdaDsn;
</STRUCT>
<MACRO>
<NAME>GDA_DSN_GDA_NAME</NAME>
#define GDA_DSN_GDA_NAME(dsn)    ((dsn) ? (dsn)->gda_name : 0)
</MACRO>
<MACRO>
<NAME>GDA_DSN_PROVIDER</NAME>
#define GDA_DSN_PROVIDER(dsn)    ((dsn) ? (dsn)->provider : 0)
</MACRO>
<MACRO>
<NAME>GDA_DSN_DSN</NAME>
#define GDA_DSN_DSN(dsn)         ((dsn) ? (dsn)->dsn_str : 0)
</MACRO>
<MACRO>
<NAME>GDA_DSN_DESCRIPTION</NAME>
#define GDA_DSN_DESCRIPTION(dsn) ((dsn) ? (dsn)->description : 0)
</MACRO>
<MACRO>
<NAME>GDA_DSN_USERNAME</NAME>
#define GDA_DSN_USERNAME(dsn)    ((dsn) ? (dsn)->username : 0)
</MACRO>
<MACRO>
<NAME>GDA_DSN_CONFIG</NAME>
#define GDA_DSN_CONFIG(dsn)      ((dsn) ? (dsn)->config : 0)
</MACRO>
<MACRO>
<NAME>GDA_DSN_IS_GLOBAL</NAME>
#define GDA_DSN_IS_GLOBAL(dsn)   ((dsn) ? (dsn)->is_global : FALSE)
</MACRO>
<MACRO>
<NAME>gda_dsn_new</NAME>
#define  gda_dsn_new() g_new0(GdaDsn, 1)
</MACRO>
<FUNCTION>
<NAME>gda_dsn_free</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_copy</NAME>
<RETURNS>GdaDsn *</RETURNS>
GdaDsn * dsn
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_find_by_name</NAME>
<RETURNS>GdaDsn *</RETURNS>
const gchar * dsn_name
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_set_name</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn, const gchar * name
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_set_provider</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn, const gchar * provider
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_set_dsn</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn, const gchar * dsn_str
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_set_description</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn,const gchar * description
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_set_username</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn, const gchar * username
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_set_config</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn, const gchar * config
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_set_global</NAME>
<RETURNS>void </RETURNS>
GdaDsn * dsn, gboolean is_global
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_save</NAME>
<RETURNS>gboolean </RETURNS>
GdaDsn * dsn
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_remove</NAME>
<RETURNS>gboolean </RETURNS>
GdaDsn * dsn
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_list</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dsn_free_list</NAME>
<RETURNS>void </RETURNS>
GList * list
</FUNCTION>
<FUNCTION>
<NAME>gda_config_save_last_connection</NAME>
<RETURNS>void </RETURNS>
const gchar * gda_name,const gchar * username
</FUNCTION>
<FUNCTION>
<NAME>gda_corba_get_orb</NAME>
<RETURNS>CORBA_ORB </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_corba_get_name_service</NAME>
<RETURNS>CORBA_Object </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_corba_handle_exception</NAME>
<RETURNS>gboolean </RETURNS>
CORBA_Environment * ev
</FUNCTION>
<FUNCTION>
<NAME>gda_corba_get_oaf_attribute</NAME>
<RETURNS>gchar *</RETURNS>
CORBA_sequence_OAF_Property props,const gchar * name
</FUNCTION>
<FUNCTION>
<NAME>gda_corba_oafiid_is_active</NAME>
<RETURNS>gboolean </RETURNS>
const gchar * oafiid
</FUNCTION>
<STRUCT>
<NAME>GdaError</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaErrorClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_ERROR</NAME>
#define GDA_TYPE_ERROR            (gda_error_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ERROR</NAME>
#define GDA_ERROR(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_ERROR, GdaError)
</MACRO>
<MACRO>
<NAME>GDA_ERROR_CLASS</NAME>
#define GDA_ERROR_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_ERROR, GdaErrorClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_ERROR</NAME>
#define GDA_IS_ERROR(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_ERROR)
</MACRO>
<MACRO>
<NAME>GDA_IS_ERROR_CLASS</NAME>
#define GDA_IS_ERROR_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_ERROR))
</MACRO>
<STRUCT>
<NAME>GdaError</NAME>
struct _GdaError {
	GtkObject object;

	gchar *description;
	glong number;
	gchar *source;
	gchar *helpurl;
	gchar *helpctxt;
	gchar *sqlstate;
	gchar *native;
	gchar *realcommand;
};
</STRUCT>
<STRUCT>
<NAME>GdaErrorClass</NAME>
struct _GdaErrorClass {
	GtkObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_error_get_type</NAME>
<RETURNS>guint </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_error_new</NAME>
<RETURNS>GdaError *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_error_list_from_exception</NAME>
<RETURNS>GList *</RETURNS>
CORBA_Environment * ev
</FUNCTION>
<FUNCTION>
<NAME>gda_error_to_exception</NAME>
<RETURNS>void </RETURNS>
GdaError * error,CORBA_Environment * ev
</FUNCTION>
<FUNCTION>
<NAME>gda_error_list_to_exception</NAME>
<RETURNS>void </RETURNS>
GList * error_list,CORBA_Environment * ev
</FUNCTION>
<FUNCTION>
<NAME>gda_error_list_to_corba_seq</NAME>
<RETURNS>GDA_ErrorSeq *</RETURNS>
GList * error_list
</FUNCTION>
<FUNCTION>
<NAME>gda_error_free</NAME>
<RETURNS>void </RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_list_free</NAME>
<RETURNS>void </RETURNS>
GList * errors
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_description</NAME>
<RETURNS>const gchar *</RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_description</NAME>
<RETURNS>void </RETURNS>
GdaError * error,const gchar * description
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_number</NAME>
<RETURNS>const glong </RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_number</NAME>
<RETURNS>void </RETURNS>
GdaError * error, glong number
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_source</NAME>
<RETURNS>const gchar *</RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_source</NAME>
<RETURNS>void </RETURNS>
GdaError * error, const gchar * source
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_help_url</NAME>
<RETURNS>const gchar *</RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_help_url</NAME>
<RETURNS>void </RETURNS>
GdaError * error, const gchar * helpurl
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_help_context</NAME>
<RETURNS>const gchar *</RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_help_context</NAME>
<RETURNS>void </RETURNS>
GdaError * error,const gchar * helpctxt
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_sqlstate</NAME>
<RETURNS>const gchar *</RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_sqlstate</NAME>
<RETURNS>void </RETURNS>
GdaError * error,const gchar * sqlstate
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_native</NAME>
<RETURNS>const gchar *</RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_native</NAME>
<RETURNS>void </RETURNS>
GdaError * error, const gchar * native
</FUNCTION>
<FUNCTION>
<NAME>gda_error_get_real_command</NAME>
<RETURNS>const gchar *</RETURNS>
GdaError * error
</FUNCTION>
<FUNCTION>
<NAME>gda_error_set_real_command</NAME>
<RETURNS>void </RETURNS>
GdaError * error,const gchar * realcommand
</FUNCTION>
<STRUCT>
<NAME>GdaListener</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaListenerClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaListenerPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_LISTENER</NAME>
#define GDA_TYPE_LISTENER            (gda_listener_get_type ())
</MACRO>
<MACRO>
<NAME>GDA_LISTENER</NAME>
#define GDA_LISTENER(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_LISTENER, GdaListener)
</MACRO>
<MACRO>
<NAME>GDA_LISTENER_CLASS</NAME>
#define GDA_LISTENER_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_LISTENER, GdaListenerClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_LISTENER</NAME>
#define GDA_IS_LISTENER(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_LISTENER)
</MACRO>
<MACRO>
<NAME>GDA_IS_LISTENER_CLASS</NAME>
#define GDA_IS_LISTENER_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_LISTENER))
</MACRO>
<STRUCT>
<NAME>GdaListener</NAME>
struct _GdaListener {
	BonoboXObject object;
	GdaListenerPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaListenerClass</NAME>
struct _GdaListenerClass {
	BonoboXObjectClass parent_class;
	POA_GDA_Listener__epv epv;

	/* signals */
	void (*notify_action) (GdaListener * listener,
			       const gchar * message,
			       GDA_ListenerAction action,
			       const gchar * description);
};
</STRUCT>
<FUNCTION>
<NAME>gda_listener_get_type</NAME>
<RETURNS>GtkType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_listener_new</NAME>
<RETURNS>GdaListener *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_listener_notify_action</NAME>
<RETURNS>void </RETURNS>
GdaListener * listener,const gchar * message,GDA_ListenerAction action,const gchar * description
</FUNCTION>
<FUNCTION>
<NAME>gda_log_enable</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_log_disable</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_log_is_enabled</NAME>
<RETURNS>gboolean </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_log_message</NAME>
<RETURNS>void </RETURNS>
const gchar * format, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_log_error</NAME>
<RETURNS>void </RETURNS>
const gchar * format, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_log_clean_all</NAME>
<RETURNS>void </RETURNS>
const gchar * prgname
</FUNCTION>
<FUNCTION>
<NAME>gda_log_clean_between</NAME>
<RETURNS>void </RETURNS>
const gchar * prgname, const gchar * from,const gchar * to
</FUNCTION>
<FUNCTION>
<NAME>gda_log_clean_entry</NAME>
<RETURNS>void </RETURNS>
const gchar * prgname, const gchar * entry
</FUNCTION>
<STRUCT>
<NAME>GdaQuarkList</NAME>
</STRUCT>
<FUNCTION>
<NAME>gda_quark_list_new</NAME>
<RETURNS>GdaQuarkList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_new_from_string</NAME>
<RETURNS>GdaQuarkList *</RETURNS>
const gchar * string
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_free</NAME>
<RETURNS>void </RETURNS>
GdaQuarkList * qlist
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_add_from_string</NAME>
<RETURNS>void </RETURNS>
GdaQuarkList * qlist,const gchar * string,gboolean cleanup
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_find</NAME>
<RETURNS>const gchar *</RETURNS>
GdaQuarkList * qlist,const gchar * name
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_THREAD</NAME>
#define GDA_TYPE_THREAD    (gda_thread_get_type())
</MACRO>
<MACRO>
<NAME>GDA_THREAD</NAME>
#define GDA_THREAD(obj)    GTK_CHECK_CAST(obj, GDA_TYPE_THREAD, GdaThread)
</MACRO>
<MACRO>
<NAME>GDA_IS_THREAD</NAME>
#define GDA_IS_THREAD(obj) GTK_CHECK_TYPE(obj, GDA_TYPE_THREAD)
</MACRO>
<STRUCT>
<NAME>GdaThread</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaThreadClass</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GdaThreadFunc</NAME>
<RETURNS>gpointer </RETURNS>
GdaThread * thr,
				   gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GdaThread</NAME>
struct _GdaThread {
	GtkObject object;

	GdaThreadFunc func;
	gulong tid;
	gboolean is_running;
};
</STRUCT>
<STRUCT>
<NAME>GdaThreadClass</NAME>
struct _GdaThreadClass {
	GtkObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_thread_get_type</NAME>
<RETURNS>GtkType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_thread_new</NAME>
<RETURNS>GdaThread *</RETURNS>
GdaThreadFunc func
</FUNCTION>
<FUNCTION>
<NAME>gda_thread_free</NAME>
<RETURNS>void </RETURNS>
GdaThread * thr
</FUNCTION>
<FUNCTION>
<NAME>gda_thread_start</NAME>
<RETURNS>void </RETURNS>
GdaThread * thr, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gda_thread_stop</NAME>
<RETURNS>void </RETURNS>
GdaThread * thr
</FUNCTION>
<FUNCTION>
<NAME>gda_thread_is_running</NAME>
<RETURNS>gboolean </RETURNS>
GdaThread * thr
</FUNCTION>
<FUNCTION>
<NAME>gda_util_hash_to_list</NAME>
<RETURNS>GList *</RETURNS>
GHashTable * hash_table
</FUNCTION>
<FUNCTION>
<NAME>gda_util_destroy_hash_pair</NAME>
<RETURNS>gboolean </RETURNS>
gchar * key, gpointer value,GFreeFunc free_func
</FUNCTION>
<FUNCTION>
<NAME>gda_util_load_file</NAME>
<RETURNS>gchar *</RETURNS>
const gchar * filename
</FUNCTION>
<FUNCTION>
<NAME>gda_util_save_file</NAME>
<RETURNS>gboolean </RETURNS>
const gchar * filename,const gchar * text
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_XML_ATOM_ITEM</NAME>
#define GDA_TYPE_XML_ATOM_ITEM            (gda_xml_atom_item_get_type ())
</MACRO>
<MACRO>
<NAME>GDA_XML_ATOM_ITEM</NAME>
#define GDA_XML_ATOM_ITEM(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_XML_ATOM_ITEM, GdaXmlAtomItem)
</MACRO>
<MACRO>
<NAME>GDA_XML_ATOM_ITEM_CLASS</NAME>
#define GDA_XML_ATOM_ITEM_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_XML_ATOM_ITEM, GdaXmlAtomItemClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_ATOM_ITEM</NAME>
#define GDA_IS_XML_ATOM_ITEM(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_XMLATOM)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_ATOM_ITEM_CLASS</NAME>
#define GDA_IS_XML_ATOM_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_XML_ATOM_ITEM))
</MACRO>
<STRUCT>
<NAME>GdaXmlAtomItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlAtomItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlAtomItem</NAME>
struct _GdaXmlAtomItem {
	GdaXmlItem item;
};
</STRUCT>
<STRUCT>
<NAME>GdaXmlAtomItemClass</NAME>
struct _GdaXmlAtomItemClass {
	GdaXmlItemClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_xml_atom_item_get_type</NAME>
<RETURNS>GtkType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_atom_item_new</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
const gchar * tag
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_XML_BIN_ITEM</NAME>
#define GDA_TYPE_XML_BIN_ITEM            (gda_xml_bin_item_get_type ())
</MACRO>
<MACRO>
<NAME>GDA_XML_BIN_ITEM</NAME>
#define GDA_XML_BIN_ITEM(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_XML_BIN_ITEM, GdaXmlBinItem)
</MACRO>
<MACRO>
<NAME>GDA_XML_BIN_ITEM_CLASS</NAME>
#define GDA_XML_BIN_ITEM_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_XML_BIN_ITEM, GdaXmlBinItemClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_BIN_ITEM</NAME>
#define GDA_IS_XML_BIN_ITEM(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_XML_BIN_ITEM)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_BIN_ITEM_CLASS</NAME>
#define GDA_IS_XML_BIN_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_XML_BIN_ITEM))
</MACRO>
<STRUCT>
<NAME>GdaXmlBinItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlBinItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlBinItemPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlBinItem</NAME>
struct _GdaXmlBinItem {
	GdaXmlItem item;
	GdaXmlBinItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaXmlBinItemClass</NAME>
struct _GdaXmlBinItemClass {
	GdaXmlItemClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_xml_bin_item_get_type</NAME>
<RETURNS>GtkType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_bin_item_new</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
const gchar * tag
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_bin_item_new_with_data</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
const gchar * tag,GdaXmlItem * child
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_bin_item_get_child</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
GdaXmlBinItem * bin
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_bin_item_set_child</NAME>
<RETURNS>void </RETURNS>
GdaXmlBinItem * bin,GdaXmlItem * child
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_bin_item_add</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item, GdaXmlItem * child
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_bin_item_to_dom</NAME>
<RETURNS>xmlNodePtr </RETURNS>
GdaXmlItem * item,xmlNodePtr parent_node
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_bin_item_find_id</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
GdaXmlItem * item,const gchar * id
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_XML_DATABASE</NAME>
#define GDA_TYPE_XML_DATABASE            (gda_xml_database_get_type())
</MACRO>
<MACRO>
<NAME>GDA_XML_DATABASE</NAME>
#define GDA_XML_DATABASE(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_XML_DATABASE, GdaXmlDatabase)
</MACRO>
<MACRO>
<NAME>GDA_XML_DATABASE_CLASS</NAME>
#define GDA_XML_DATABASE_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_XML_DATABASE, GdaXmlDatabaseClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_DATABASE</NAME>
#define GDA_IS_XML_DATABASE(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_XML_DATABASE)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_DATABASE_CLASS</NAME>
#define GDA_IS_XML_DATABASE_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_XML_DATABASE))
</MACRO>
<STRUCT>
<NAME>GdaXmlDatabase</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlDatabaseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlDatabasePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlDatabase</NAME>
struct _GdaXmlDatabase {
	GdaXmlDocument document;
	GdaXmlDatabasePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaXmlDatabaseClass</NAME>
struct _GdaXmlDatabaseClass {
	GdaXmlDocumentClass parent_class;

	/* signals */
	void (*changed) (GdaXmlDatabase * xmldb);
};
</STRUCT>
<FUNCTION>
<NAME>gda_xml_database_get_type</NAME>
<RETURNS>GtkType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_new</NAME>
<RETURNS>GdaXmlDatabase *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_new_from_file</NAME>
<RETURNS>GdaXmlDatabase *</RETURNS>
const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_free</NAME>
<RETURNS>void            </RETURNS>
GdaXmlDatabase * xmldb
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_save</NAME>
<RETURNS>gboolean        </RETURNS>
GdaXmlDatabase * xmldb,const gchar * filename
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_changed</NAME>
<RETURNS>void            </RETURNS>
GdaXmlDatabase * xmldb
</FUNCTION>
<TYPEDEF>
<NAME>GdaXmlDatabaseTable</NAME>
typedef xmlNode GdaXmlDatabaseTable;
</TYPEDEF>
<FUNCTION>
<NAME>gda_xml_database_get_tables</NAME>
<RETURNS>GList               *</RETURNS>
GdaXmlDatabase *xmldb
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_new</NAME>
<RETURNS>GdaXmlDatabaseTable *</RETURNS>
GdaXmlDatabase *xmldb, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_remove</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_find</NAME>
<RETURNS>GdaXmlDatabaseTable *</RETURNS>
GdaXmlDatabase *xmldb,const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_get_name</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaXmlDatabase * xmldb,GdaXmlDatabaseTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_set_name</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table,const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_get_owner</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_set_owner</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table,const gchar *owner
</FUNCTION>
<TYPEDEF>
<NAME>GdaXmlDatabaseField</NAME>
typedef xmlNode GdaXmlDatabaseField;
</TYPEDEF>
<FUNCTION>
<NAME>gda_xml_database_table_field_count</NAME>
<RETURNS>gint                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_add_field</NAME>
<RETURNS>GdaXmlDatabaseField *</RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table,const gchar *fname
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_remove_field</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table,const gchar *fname
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_get_field</NAME>
<RETURNS>GdaXmlDatabaseField *</RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table,gint pos
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_table_find_field</NAME>
<RETURNS>GdaXmlDatabaseField *</RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseTable *table,const gchar *fname
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_get_name</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_set_name</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field,const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_get_gdatype</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_set_gdatype</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field,const gchar *type
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_get_size</NAME>
<RETURNS>gint                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_set_size</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field,gint size
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_get_scale</NAME>
<RETURNS>gint                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_database_field_set_scale</NAME>
<RETURNS>void                 </RETURNS>
GdaXmlDatabase *xmldb,GdaXmlDatabaseField *field,gint scale
</FUNCTION>
<STRUCT>
<NAME>GdaXmlDocument</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlDocumentClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_XML_DOCUMENT</NAME>
#define GDA_TYPE_XML_DOCUMENT            (gda_xml_document_get_type())
</MACRO>
<MACRO>
<NAME>GDA_XML_DOCUMENT</NAME>
#define GDA_XML_DOCUMENT(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_XML_DOCUMENT, GdaXmlDocument)
</MACRO>
<MACRO>
<NAME>GDA_XML_DOCUMENT_CLASS</NAME>
#define GDA_XML_DOCUMENT_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_XML_DOCUMENT, GdaXmlDocumentClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_DOCUMENT</NAME>
#define GDA_IS_XML_DOCUMENT(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_XML_DOCUMENT)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_DOCUMENT_CLASS</NAME>
#define GDA_IS_XML_DOCUMENT_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_XML_DOCUMENT))
</MACRO>
<STRUCT>
<NAME>GdaXmlDocument</NAME>
struct _GdaXmlDocument {
	GtkObject object;

	xmlDocPtr doc;
	xmlDtdPtr dtd;
	xmlNodePtr root;
	xmlValidCtxtPtr context;
};
</STRUCT>
<STRUCT>
<NAME>GdaXmlDocumentClass</NAME>
struct _GdaXmlDocumentClass {
	GtkObjectClass parent_class;

	void (*warning) (GdaXmlDocument * q, const char *msg);
	void (*error) (GdaXmlDocument * q, const char *msg);
};
</STRUCT>
<FUNCTION>
<NAME>gda_xml_document_get_type</NAME>
<RETURNS>GtkType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_document_new</NAME>
<RETURNS>GdaXmlDocument *</RETURNS>
const gchar * root_doc
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_document_construct</NAME>
<RETURNS>void            </RETURNS>
GdaXmlDocument * xmlfile,const gchar * root_doc
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_document_get_compress_mode</NAME>
<RETURNS>gint            </RETURNS>
GdaXmlDocument *xmldoc
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_document_set_compress_mode</NAME>
<RETURNS>void            </RETURNS>
GdaXmlDocument *xmldoc, gint mode
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_document_to_file</NAME>
<RETURNS>gint            </RETURNS>
GdaXmlDocument * xmldoc,const gchar * filename
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_document_stringify</NAME>
<RETURNS>gchar          *</RETURNS>
GdaXmlDocument * xmldoc
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_XML_ITEM</NAME>
#define GDA_TYPE_XML_ITEM (gda_xml_item_get_type ())
</MACRO>
<MACRO>
<NAME>GDA_XML_ITEM</NAME>
#define GDA_XML_ITEM(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_XML_ITEM, GdaXmlItem)
</MACRO>
<MACRO>
<NAME>GDA_XML_ITEM_CLASS</NAME>
#define GDA_XML_ITEM_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_XML_ITEM, GdaXmlItemClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_ITEM</NAME>
#define GDA_IS_XML_ITEM(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_XML_ITEM)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_ITEM_CLASS</NAME>
#define GDA_IS_XML_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_XML_ITEM))
</MACRO>
<STRUCT>
<NAME>GdaXmlItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlItemPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlItem</NAME>
struct _GdaXmlItem {
	GtkObject object;
	GdaXmlItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaXmlItemClass</NAME>
struct _GdaXmlItemClass {
	GtkObjectClass *object_class;

	/* virtual methods */
	void (*add) (GdaXmlItem * item, GdaXmlItem * child);
	  xmlNodePtr (*to_dom) (GdaXmlItem * item,
				xmlNodePtr parent_node);
	GdaXmlItem *(*find_id) (GdaXmlItem * item, const gchar * id);
};
</STRUCT>
<FUNCTION>
<NAME>gda_xml_item_get_type</NAME>
<RETURNS>GtkType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_free</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_add</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item, GdaXmlItem * child
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_to_dom</NAME>
<RETURNS>xmlNodePtr </RETURNS>
GdaXmlItem * item,xmlNodePtr parent_node
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_get_attribute</NAME>
<RETURNS>const gchar *</RETURNS>
GdaXmlItem * item,const gchar * attrib
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_set_attribute</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item,const gchar * attrib,const gchar * value
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_get_tag</NAME>
<RETURNS>const gchar *</RETURNS>
GdaXmlItem * item
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_set_tag</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item, const gchar * tag
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_get_parent</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
GdaXmlItem * item
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_set_parent</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item, GdaXmlItem * parent
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_find_root</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
GdaXmlItem * item
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_find_id</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
GdaXmlItem * item,const gchar * id
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_find_ref</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
GdaXmlItem * item,const gchar * ref
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_add_id</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item, const gchar * id
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_item_add_ref</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item, const gchar * ref
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_XML_LIST_ITEM</NAME>
#define GDA_TYPE_XML_LIST_ITEM            (gda_xml_list_item_get_type ())
</MACRO>
<MACRO>
<NAME>GDA_XML_LIST_ITEM</NAME>
#define GDA_XML_LIST_ITEM(obj)            GTK_CHECK_CAST(obj, GDA_TYPE_XML_LIST_ITEM, GdaXmlListItem)
</MACRO>
<MACRO>
<NAME>GDA_XML_LIST_ITEM_CLASS</NAME>
#define GDA_XML_LIST_ITEM_CLASS(klass)    GTK_CHECK_CLASS_CAST(klass, GDA_TYPE_XML_LIST_ITEM, GdaXmlListItemClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_LIST_ITEM</NAME>
#define GDA_IS_XML_LIST_ITEM(obj)         GTK_CHECK_TYPE(obj, GDA_TYPE_XML_LIST_ITEM)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_LIST_ITEM_CLASS</NAME>
#define GDA_IS_XML_LIST_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GDA_TYPE_XML_LIST_ITEM))
</MACRO>
<STRUCT>
<NAME>GdaXmlListItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlListItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlListItemPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlListItem</NAME>
struct _GdaXmlListItem {
	GdaXmlItem item;
	GdaXmlListItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaXmlListItemClass</NAME>
struct _GdaXmlListItemClass {
	GdaXmlItemClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_xml_list_item_get_type</NAME>
<RETURNS>GtkType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_list_item_new</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
const gchar * tag
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_list_item_add</NAME>
<RETURNS>void </RETURNS>
GdaXmlItem * item, GdaXmlItem * child
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_list_item_to_dom</NAME>
<RETURNS>xmlNodePtr </RETURNS>
GdaXmlItem * item,xmlNodePtr parent_node
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_list_item_find_id</NAME>
<RETURNS>GdaXmlItem *</RETURNS>
GdaXmlItem * item,const gchar * id
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_util_gensym</NAME>
<RETURNS>gchar *</RETURNS>
const gchar * sym
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_util_dom_to_xml</NAME>
<RETURNS>gchar *</RETURNS>
xmlNodePtr node, gboolean freedoc
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_util_dom_to_sql</NAME>
<RETURNS>gchar *</RETURNS>
xmlNodePtr node, gboolean freedoc
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_util_new_node</NAME>
<RETURNS>xmlNodePtr </RETURNS>
const gchar * tag,xmlNodePtr parent_node
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_util_new_attr</NAME>
<RETURNS>void </RETURNS>
gchar * key, gchar * value,xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>gda_init</NAME>
<RETURNS>void </RETURNS>
const gchar * app_id, const gchar * version, gint nargs,gchar * args[]
</FUNCTION>
<MACRO>
<NAME>_</NAME>
#  define _(String) gettext (String)
</MACRO>
<MACRO>
<NAME>N_</NAME>
#  define N_(String) (String)
</MACRO>
<MACRO>
<NAME>textdomain</NAME>
#  define textdomain(String)
</MACRO>
<MACRO>
<NAME>gettext</NAME>
#  define gettext(String) (String)
</MACRO>
<MACRO>
<NAME>dgettext</NAME>
#  define dgettext(Domain,Message) (Message)
</MACRO>
<MACRO>
<NAME>dcgettext</NAME>
#  define dcgettext(Domain,Message,Type) (Message)
</MACRO>
<MACRO>
<NAME>bindtextdomain</NAME>
#  define bindtextdomain(Domain,Directory)
</MACRO>
<MACRO>
<NAME>_</NAME>
#  define _(String) (String)
</MACRO>
<MACRO>
<NAME>N_</NAME>
#  define N_(String) (String)
</MACRO>
<MACRO>
<NAME>ORBIT_IDL_SERIAL</NAME>
#define ORBIT_IDL_SERIAL 9
</MACRO>
<MACRO>
<NAME>GDA_H</NAME>
#define GDA_H 1
</MACRO>
<STRUCT>
<NAME>GDA_Error</NAME>
typedef struct {
CORBA_char * description;
CORBA_long number;
CORBA_char * source;
CORBA_char * sqlstate;
CORBA_char * nativeMsg;
} GDA_Error;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Error_0</NAME>
#define TC_IMPL_TC_GDA_Error_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Error_1</NAME>
#define TC_IMPL_TC_GDA_Error_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Error_2</NAME>
#define TC_IMPL_TC_GDA_Error_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Error</NAME>
#define TC_GDA_Error ((CORBA_TypeCode)&TC_GDA_Error_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Error__alloc</NAME>
<RETURNS>GDA_Error*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Error__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_GDA_Error</NAME>
#define ORBIT_DECL_CORBA_sequence_GDA_Error 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Error_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Error_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Error_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Error_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Error_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Error_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_GDA_Error</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; GDA_Error* _buffer; CORBA_boolean _release; } CORBA_sequence_GDA_Error;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Error_allocbuf</NAME>
<RETURNS>GDA_Error *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Error_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Error_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Error_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Error_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Error_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Error_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_GDA_Error</NAME>
#define TC_CORBA_sequence_GDA_Error ((CORBA_TypeCode)&TC_CORBA_sequence_GDA_Error_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Error__alloc</NAME>
<RETURNS>CORBA_sequence_GDA_Error*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Error__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_ErrorSeq</NAME>
typedef CORBA_sequence_GDA_Error GDA_ErrorSeq;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ErrorSeq_0</NAME>
#define TC_IMPL_TC_GDA_ErrorSeq_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ErrorSeq_1</NAME>
#define TC_IMPL_TC_GDA_ErrorSeq_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ErrorSeq_2</NAME>
#define TC_IMPL_TC_GDA_ErrorSeq_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_ErrorSeq</NAME>
#define TC_GDA_ErrorSeq ((CORBA_TypeCode)&TC_GDA_ErrorSeq_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_ErrorSeq__alloc</NAME>
<RETURNS>GDA_ErrorSeq*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_ErrorSeq__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ex_GDA_DriverError</NAME>
#define ex_GDA_DriverError "IDL:GDA/DriverError:1.0"
</MACRO>
<STRUCT>
<NAME>GDA_DriverError</NAME>
typedef struct {
GDA_ErrorSeq errors;
CORBA_char * realcommand;
} GDA_DriverError;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DriverError_0</NAME>
#define TC_IMPL_TC_GDA_DriverError_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DriverError_1</NAME>
#define TC_IMPL_TC_GDA_DriverError_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DriverError_2</NAME>
#define TC_IMPL_TC_GDA_DriverError_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_DriverError</NAME>
#define TC_GDA_DriverError ((CORBA_TypeCode)&TC_GDA_DriverError_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_DriverError__alloc</NAME>
<RETURNS>GDA_DriverError*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_DriverError__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ex_GDA_NotSupported</NAME>
#define ex_GDA_NotSupported "IDL:GDA/NotSupported:1.0"
</MACRO>
<STRUCT>
<NAME>GDA_NotSupported</NAME>
typedef struct {
CORBA_char * errormsg;
} GDA_NotSupported;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_NotSupported_0</NAME>
#define TC_IMPL_TC_GDA_NotSupported_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_NotSupported_1</NAME>
#define TC_IMPL_TC_GDA_NotSupported_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_NotSupported_2</NAME>
#define TC_IMPL_TC_GDA_NotSupported_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_NotSupported</NAME>
#define TC_GDA_NotSupported ((CORBA_TypeCode)&TC_GDA_NotSupported_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_NotSupported__alloc</NAME>
<RETURNS>GDA_NotSupported*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_NotSupported__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<ENUM>
<NAME>GDA_ListenerAction</NAME>
typedef enum {
  GDA_LISTENER_ACTION_DATABASE,
  GDA_LISTENER_ACTION_ERROR,
  GDA_LISTENER_ACTION_SHUTDOWN
} GDA_ListenerAction;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ListenerAction_0</NAME>
#define TC_IMPL_TC_GDA_ListenerAction_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ListenerAction_1</NAME>
#define TC_IMPL_TC_GDA_ListenerAction_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ListenerAction_2</NAME>
#define TC_IMPL_TC_GDA_ListenerAction_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_ListenerAction</NAME>
#define TC_GDA_ListenerAction ((CORBA_TypeCode)&TC_GDA_ListenerAction_struct)
</MACRO>
<MACRO>
<NAME>ORBIT_DECL_GDA_Listener</NAME>
#define ORBIT_DECL_GDA_Listener 1
</MACRO>
<MACRO>
<NAME>GDA_Listener__free</NAME>
#define GDA_Listener__free CORBA_Object__free
</MACRO>
<TYPEDEF>
<NAME>GDA_Listener</NAME>
typedef CORBA_Object GDA_Listener;
</TYPEDEF>
<VARIABLE>
<NAME>GDA_Listener__classid</NAME>
extern CORBA_unsigned_long GDA_Listener__classid;
</VARIABLE>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Listener_0</NAME>
#define TC_IMPL_TC_GDA_Listener_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Listener_1</NAME>
#define TC_IMPL_TC_GDA_Listener_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Listener_2</NAME>
#define TC_IMPL_TC_GDA_Listener_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Listener</NAME>
#define TC_GDA_Listener ((CORBA_TypeCode)&TC_GDA_Listener_struct)
</MACRO>
<ENUM>
<NAME>GDA_ValueType</NAME>
typedef enum {
  GDA_TypeNull,
  GDA_TypeBigint,
  GDA_TypeBinary,
  GDA_TypeBoolean,
  GDA_TypeBstr,
  GDA_TypeChar,
  GDA_TypeCurrency,
  GDA_TypeDate,
  GDA_TypeDbDate,
  GDA_TypeDbTime,
  GDA_TypeDbTimestamp,
  GDA_TypeDecimal,
  GDA_TypeDouble,
  GDA_TypeError,
  GDA_TypeInteger,
  GDA_TypeLongvarbin,
  GDA_TypeLongvarchar,
  GDA_TypeLongvarwchar,
  GDA_TypeNumeric,
  GDA_TypeSingle,
  GDA_TypeSmallint,
  GDA_TypeTinyint,
  GDA_TypeUBigint,
  GDA_TypeUSmallint,
  GDA_TypeVarchar,
  GDA_TypeVarbin,
  GDA_TypeVarwchar,
  GDA_TypeFixchar,
  GDA_TypeFixbin,
  GDA_TypeFixwchar,
  GDA_TypeUnknown,
  GDA_TypeLastValue
} GDA_ValueType;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ValueType_0</NAME>
#define TC_IMPL_TC_GDA_ValueType_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ValueType_1</NAME>
#define TC_IMPL_TC_GDA_ValueType_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ValueType_2</NAME>
#define TC_IMPL_TC_GDA_ValueType_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_ValueType</NAME>
#define TC_GDA_ValueType ((CORBA_TypeCode)&TC_GDA_ValueType_struct)
</MACRO>
<TYPEDEF>
<NAME>GDA_Date</NAME>
typedef CORBA_long GDA_Date;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Date_0</NAME>
#define TC_IMPL_TC_GDA_Date_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Date_1</NAME>
#define TC_IMPL_TC_GDA_Date_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Date_2</NAME>
#define TC_IMPL_TC_GDA_Date_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Date</NAME>
#define TC_GDA_Date ((CORBA_TypeCode)&TC_GDA_Date_struct)
</MACRO>
<STRUCT>
<NAME>GDA_DbDate</NAME>
typedef struct {
CORBA_short year;
CORBA_unsigned_short month;
CORBA_unsigned_short day;
} GDA_DbDate;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbDate_0</NAME>
#define TC_IMPL_TC_GDA_DbDate_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbDate_1</NAME>
#define TC_IMPL_TC_GDA_DbDate_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbDate_2</NAME>
#define TC_IMPL_TC_GDA_DbDate_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_DbDate</NAME>
#define TC_GDA_DbDate ((CORBA_TypeCode)&TC_GDA_DbDate_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_DbDate__alloc</NAME>
<RETURNS>GDA_DbDate*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_DbDate__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<STRUCT>
<NAME>GDA_DbTime</NAME>
typedef struct {
CORBA_unsigned_short hour;
CORBA_unsigned_short minute;
CORBA_unsigned_short second;
} GDA_DbTime;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbTime_0</NAME>
#define TC_IMPL_TC_GDA_DbTime_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbTime_1</NAME>
#define TC_IMPL_TC_GDA_DbTime_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbTime_2</NAME>
#define TC_IMPL_TC_GDA_DbTime_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_DbTime</NAME>
#define TC_GDA_DbTime ((CORBA_TypeCode)&TC_GDA_DbTime_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_DbTime__alloc</NAME>
<RETURNS>GDA_DbTime*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_DbTime__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<STRUCT>
<NAME>GDA_DbTimestamp</NAME>
typedef struct {
CORBA_short year;
CORBA_unsigned_short month;
CORBA_unsigned_short day;
CORBA_unsigned_short hour;
CORBA_unsigned_short minute;
CORBA_unsigned_short second;
CORBA_unsigned_long fraction;
} GDA_DbTimestamp;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbTimestamp_0</NAME>
#define TC_IMPL_TC_GDA_DbTimestamp_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbTimestamp_1</NAME>
#define TC_IMPL_TC_GDA_DbTimestamp_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_DbTimestamp_2</NAME>
#define TC_IMPL_TC_GDA_DbTimestamp_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_DbTimestamp</NAME>
#define TC_GDA_DbTimestamp ((CORBA_TypeCode)&TC_GDA_DbTimestamp_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_DbTimestamp__alloc</NAME>
<RETURNS>GDA_DbTimestamp*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_DbTimestamp__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_CORBA_octet</NAME>
#define ORBIT_DECL_CORBA_sequence_CORBA_octet 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_CORBA_octet_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_CORBA_octet_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_CORBA_octet_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_CORBA_octet</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; CORBA_octet* _buffer; CORBA_boolean _release; } CORBA_sequence_CORBA_octet;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_CORBA_octet_allocbuf</NAME>
<RETURNS>CORBA_octet *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_CORBA_octet_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_CORBA_octet_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_CORBA_octet_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_CORBA_octet</NAME>
#define TC_CORBA_sequence_CORBA_octet ((CORBA_TypeCode)&TC_CORBA_sequence_CORBA_octet_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_CORBA_octet__alloc</NAME>
<RETURNS>CORBA_sequence_CORBA_octet*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_CORBA_octet__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_VarBinString</NAME>
typedef CORBA_sequence_CORBA_octet GDA_VarBinString;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_VarBinString_0</NAME>
#define TC_IMPL_TC_GDA_VarBinString_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_VarBinString_1</NAME>
#define TC_IMPL_TC_GDA_VarBinString_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_VarBinString_2</NAME>
#define TC_IMPL_TC_GDA_VarBinString_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_VarBinString</NAME>
#define TC_GDA_VarBinString ((CORBA_TypeCode)&TC_GDA_VarBinString_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_VarBinString__alloc</NAME>
<RETURNS>GDA_VarBinString*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_VarBinString__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<STRUCT>
<NAME>GDA_Value</NAME>
typedef struct {
GDA_ValueType _d;
union {
CORBA_char c;
CORBA_long_long ll;
CORBA_boolean b;
GDA_Date d;
GDA_DbDate dbd;
GDA_DbTime dbt;
GDA_DbTimestamp dbtstamp;
CORBA_double dp;
CORBA_long i;
GDA_VarBinString lvb;
GDA_VarBinString fb;
CORBA_char * lvc;
CORBA_float f;
CORBA_short si;
CORBA_unsigned_long_long ull;
CORBA_unsigned_short us;
} _u;
} GDA_Value;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Value_0</NAME>
#define TC_IMPL_TC_GDA_Value_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Value_1</NAME>
#define TC_IMPL_TC_GDA_Value_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Value_2</NAME>
#define TC_IMPL_TC_GDA_Value_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Value</NAME>
#define TC_GDA_Value ((CORBA_TypeCode)&TC_GDA_Value_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Value__alloc</NAME>
<RETURNS>GDA_Value*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Value__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<STRUCT>
<NAME>GDA_FieldValue</NAME>
typedef struct {
CORBA_boolean _d;
union {
GDA_Value v;
} _u;
} GDA_FieldValue;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_FieldValue_0</NAME>
#define TC_IMPL_TC_GDA_FieldValue_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_FieldValue_1</NAME>
#define TC_IMPL_TC_GDA_FieldValue_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_FieldValue_2</NAME>
#define TC_IMPL_TC_GDA_FieldValue_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_FieldValue</NAME>
#define TC_GDA_FieldValue ((CORBA_TypeCode)&TC_GDA_FieldValue_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_FieldValue__alloc</NAME>
<RETURNS>GDA_FieldValue*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_FieldValue__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<STRUCT>
<NAME>GDA_Field</NAME>
typedef struct {
CORBA_long actualSize;
GDA_FieldValue originalValue;
GDA_FieldValue shadowValue;
GDA_FieldValue realValue;
} GDA_Field;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Field_0</NAME>
#define TC_IMPL_TC_GDA_Field_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Field_1</NAME>
#define TC_IMPL_TC_GDA_Field_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Field_2</NAME>
#define TC_IMPL_TC_GDA_Field_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Field</NAME>
#define TC_GDA_Field ((CORBA_TypeCode)&TC_GDA_Field_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Field__alloc</NAME>
<RETURNS>GDA_Field*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Field__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<STRUCT>
<NAME>GDA_FieldAttributes</NAME>
typedef struct {
CORBA_long definedSize;
CORBA_char * name;
CORBA_long scale;
GDA_ValueType gdaType;
CORBA_long cType;
CORBA_long nativeType;
} GDA_FieldAttributes;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_FieldAttributes_0</NAME>
#define TC_IMPL_TC_GDA_FieldAttributes_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_FieldAttributes_1</NAME>
#define TC_IMPL_TC_GDA_FieldAttributes_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_FieldAttributes_2</NAME>
#define TC_IMPL_TC_GDA_FieldAttributes_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_FieldAttributes</NAME>
#define TC_GDA_FieldAttributes ((CORBA_TypeCode)&TC_GDA_FieldAttributes_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_FieldAttributes__alloc</NAME>
<RETURNS>GDA_FieldAttributes*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_FieldAttributes__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_GDA_Field</NAME>
#define ORBIT_DECL_CORBA_sequence_GDA_Field 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Field_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Field_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Field_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Field_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Field_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Field_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_GDA_Field</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; GDA_Field* _buffer; CORBA_boolean _release; } CORBA_sequence_GDA_Field;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Field_allocbuf</NAME>
<RETURNS>GDA_Field *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Field_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Field_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Field_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Field_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Field_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Field_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_GDA_Field</NAME>
#define TC_CORBA_sequence_GDA_Field ((CORBA_TypeCode)&TC_CORBA_sequence_GDA_Field_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Field__alloc</NAME>
<RETURNS>CORBA_sequence_GDA_Field*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Field__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_Row</NAME>
typedef CORBA_sequence_GDA_Field GDA_Row;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Row_0</NAME>
#define TC_IMPL_TC_GDA_Row_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Row_1</NAME>
#define TC_IMPL_TC_GDA_Row_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Row_2</NAME>
#define TC_IMPL_TC_GDA_Row_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Row</NAME>
#define TC_GDA_Row ((CORBA_TypeCode)&TC_GDA_Row_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Row__alloc</NAME>
<RETURNS>GDA_Row*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Row__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_GDA_FieldAttributes</NAME>
#define ORBIT_DECL_CORBA_sequence_GDA_FieldAttributes 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_GDA_FieldAttributes</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; GDA_FieldAttributes* _buffer; CORBA_boolean _release; } CORBA_sequence_GDA_FieldAttributes;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_GDA_FieldAttributes_allocbuf</NAME>
<RETURNS>GDA_FieldAttributes *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_GDA_FieldAttributes</NAME>
#define TC_CORBA_sequence_GDA_FieldAttributes ((CORBA_TypeCode)&TC_CORBA_sequence_GDA_FieldAttributes_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_GDA_FieldAttributes__alloc</NAME>
<RETURNS>CORBA_sequence_GDA_FieldAttributes*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_GDA_FieldAttributes__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_RowAttributes</NAME>
typedef CORBA_sequence_GDA_FieldAttributes GDA_RowAttributes;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_RowAttributes_0</NAME>
#define TC_IMPL_TC_GDA_RowAttributes_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_RowAttributes_1</NAME>
#define TC_IMPL_TC_GDA_RowAttributes_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_RowAttributes_2</NAME>
#define TC_IMPL_TC_GDA_RowAttributes_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_RowAttributes</NAME>
#define TC_GDA_RowAttributes ((CORBA_TypeCode)&TC_GDA_RowAttributes_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_RowAttributes__alloc</NAME>
<RETURNS>GDA_RowAttributes*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_RowAttributes__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<ENUM>
<NAME>GDA_LockType</NAME>
typedef enum {
  GDA_LOCK_READONLY,
  GDA_LOCK_PESSIMISTIC,
  GDA_LOCK_OPTIMISTIC,
  GDA_LOCK_BATCH
} GDA_LockType;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_LockType_0</NAME>
#define TC_IMPL_TC_GDA_LockType_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_LockType_1</NAME>
#define TC_IMPL_TC_GDA_LockType_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_LockType_2</NAME>
#define TC_IMPL_TC_GDA_LockType_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_LockType</NAME>
#define TC_GDA_LockType ((CORBA_TypeCode)&TC_GDA_LockType_struct)
</MACRO>
<ENUM>
<NAME>GDA_CursorType</NAME>
typedef enum {
  GDA_OPEN_FWDONLY,
  GDA_OPEN_KEYSET,
  GDA_OPEN_DYNAMIC,
  GDA_OPEN_STATIC
} GDA_CursorType;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CursorType_0</NAME>
#define TC_IMPL_TC_GDA_CursorType_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CursorType_1</NAME>
#define TC_IMPL_TC_GDA_CursorType_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CursorType_2</NAME>
#define TC_IMPL_TC_GDA_CursorType_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_CursorType</NAME>
#define TC_GDA_CursorType ((CORBA_TypeCode)&TC_GDA_CursorType_struct)
</MACRO>
<ENUM>
<NAME>GDA_Option</NAME>
typedef enum {
  GDA_ADD_NEW,
  GDA_APPROX_POS,
  GDA_BOOKMARK,
  GDA_DELETE,
  GDA_HOLD_RECS,
  GDA_MOVE_PREV,
  GDA_DO_RESYNC,
  GDA_DO_UPDATE,
  GDA_UPDATE_BATCH
} GDA_Option;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Option_0</NAME>
#define TC_IMPL_TC_GDA_Option_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Option_1</NAME>
#define TC_IMPL_TC_GDA_Option_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Option_2</NAME>
#define TC_IMPL_TC_GDA_Option_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Option</NAME>
#define TC_GDA_Option ((CORBA_TypeCode)&TC_GDA_Option_struct)
</MACRO>
<MACRO>
<NAME>ORBIT_DECL_GDA_Recordset</NAME>
#define ORBIT_DECL_GDA_Recordset 1
</MACRO>
<MACRO>
<NAME>GDA_Recordset__free</NAME>
#define GDA_Recordset__free CORBA_Object__free
</MACRO>
<TYPEDEF>
<NAME>GDA_Recordset</NAME>
typedef CORBA_Object GDA_Recordset;
</TYPEDEF>
<VARIABLE>
<NAME>GDA_Recordset__classid</NAME>
extern CORBA_unsigned_long GDA_Recordset__classid;
</VARIABLE>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Recordset_0</NAME>
#define TC_IMPL_TC_GDA_Recordset_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Recordset_1</NAME>
#define TC_IMPL_TC_GDA_Recordset_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Recordset_2</NAME>
#define TC_IMPL_TC_GDA_Recordset_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Recordset</NAME>
#define TC_GDA_Recordset ((CORBA_TypeCode)&TC_GDA_Recordset_struct)
</MACRO>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_GDA_Row</NAME>
#define ORBIT_DECL_CORBA_sequence_GDA_Row 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Row_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Row_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Row_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Row_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Row_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Row_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_GDA_Row</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; GDA_Row* _buffer; CORBA_boolean _release; } CORBA_sequence_GDA_Row;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Row_allocbuf</NAME>
<RETURNS>GDA_Row *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Row_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Row_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Row_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Row_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Row_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Row_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_GDA_Row</NAME>
#define TC_CORBA_sequence_GDA_Row ((CORBA_TypeCode)&TC_CORBA_sequence_GDA_Row_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Row__alloc</NAME>
<RETURNS>CORBA_sequence_GDA_Row*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Row__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_Recordset_Chunk</NAME>
typedef CORBA_sequence_GDA_Row GDA_Recordset_Chunk;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Recordset_Chunk_0</NAME>
#define TC_IMPL_TC_GDA_Recordset_Chunk_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Recordset_Chunk_1</NAME>
#define TC_IMPL_TC_GDA_Recordset_Chunk_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Recordset_Chunk_2</NAME>
#define TC_IMPL_TC_GDA_Recordset_Chunk_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Recordset_Chunk</NAME>
#define TC_GDA_Recordset_Chunk ((CORBA_TypeCode)&TC_GDA_Recordset_Chunk_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Recordset_Chunk__alloc</NAME>
<RETURNS>GDA_Recordset_Chunk*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_Chunk__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ORBIT_DECL_GDA_Parameter</NAME>
#define ORBIT_DECL_GDA_Parameter 1
</MACRO>
<MACRO>
<NAME>GDA_Parameter__free</NAME>
#define GDA_Parameter__free CORBA_Object__free
</MACRO>
<TYPEDEF>
<NAME>GDA_Parameter</NAME>
typedef CORBA_Object GDA_Parameter;
</TYPEDEF>
<VARIABLE>
<NAME>GDA_Parameter__classid</NAME>
extern CORBA_unsigned_long GDA_Parameter__classid;
</VARIABLE>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Parameter_0</NAME>
#define TC_IMPL_TC_GDA_Parameter_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Parameter_1</NAME>
#define TC_IMPL_TC_GDA_Parameter_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Parameter_2</NAME>
#define TC_IMPL_TC_GDA_Parameter_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Parameter</NAME>
#define TC_GDA_Parameter ((CORBA_TypeCode)&TC_GDA_Parameter_struct)
</MACRO>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_CORBA_octet</NAME>
#define ORBIT_DECL_CORBA_sequence_CORBA_octet 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_CORBA_octet_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_CORBA_octet_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_CORBA_octet_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_CORBA_octet_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_CORBA_octet</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; CORBA_octet* _buffer; CORBA_boolean _release; } CORBA_sequence_CORBA_octet;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_CORBA_octet_allocbuf</NAME>
<RETURNS>CORBA_octet *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_CORBA_octet_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_CORBA_octet_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_CORBA_octet_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_CORBA_octet_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_CORBA_octet</NAME>
#define TC_CORBA_sequence_CORBA_octet ((CORBA_TypeCode)&TC_CORBA_sequence_CORBA_octet_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_CORBA_octet__alloc</NAME>
<RETURNS>CORBA_sequence_CORBA_octet*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_CORBA_octet__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_Parameter_VarBinString</NAME>
typedef CORBA_sequence_CORBA_octet GDA_Parameter_VarBinString;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Parameter_VarBinString_0</NAME>
#define TC_IMPL_TC_GDA_Parameter_VarBinString_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Parameter_VarBinString_1</NAME>
#define TC_IMPL_TC_GDA_Parameter_VarBinString_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Parameter_VarBinString_2</NAME>
#define TC_IMPL_TC_GDA_Parameter_VarBinString_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Parameter_VarBinString</NAME>
#define TC_GDA_Parameter_VarBinString ((CORBA_TypeCode)&TC_GDA_Parameter_VarBinString_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Parameter_VarBinString__alloc</NAME>
<RETURNS>GDA_Parameter_VarBinString*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Parameter_VarBinString__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<ENUM>
<NAME>GDA_ParameterDirection</NAME>
typedef enum {
  GDA_PARAM_IN,
  GDA_PARAM_OUT,
  GDA_PARAM_INOUT
} GDA_ParameterDirection;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ParameterDirection_0</NAME>
#define TC_IMPL_TC_GDA_ParameterDirection_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ParameterDirection_1</NAME>
#define TC_IMPL_TC_GDA_ParameterDirection_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_ParameterDirection_2</NAME>
#define TC_IMPL_TC_GDA_ParameterDirection_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_ParameterDirection</NAME>
#define TC_GDA_ParameterDirection ((CORBA_TypeCode)&TC_GDA_ParameterDirection_struct)
</MACRO>
<STRUCT>
<NAME>GDA_CmdParameter</NAME>
typedef struct {
GDA_FieldValue value;
GDA_ParameterDirection dir;
CORBA_char * name;
CORBA_long precision;
CORBA_long scale;
} GDA_CmdParameter;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CmdParameter_0</NAME>
#define TC_IMPL_TC_GDA_CmdParameter_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CmdParameter_1</NAME>
#define TC_IMPL_TC_GDA_CmdParameter_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CmdParameter_2</NAME>
#define TC_IMPL_TC_GDA_CmdParameter_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_CmdParameter</NAME>
#define TC_GDA_CmdParameter ((CORBA_TypeCode)&TC_GDA_CmdParameter_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_CmdParameter__alloc</NAME>
<RETURNS>GDA_CmdParameter*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_CmdParameter__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_GDA_CmdParameter</NAME>
#define ORBIT_DECL_CORBA_sequence_GDA_CmdParameter 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_GDA_CmdParameter</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; GDA_CmdParameter* _buffer; CORBA_boolean _release; } CORBA_sequence_GDA_CmdParameter;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_GDA_CmdParameter_allocbuf</NAME>
<RETURNS>GDA_CmdParameter *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_GDA_CmdParameter</NAME>
#define TC_CORBA_sequence_GDA_CmdParameter ((CORBA_TypeCode)&TC_CORBA_sequence_GDA_CmdParameter_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_GDA_CmdParameter__alloc</NAME>
<RETURNS>CORBA_sequence_GDA_CmdParameter*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_GDA_CmdParameter__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_CmdParameterSeq</NAME>
typedef CORBA_sequence_GDA_CmdParameter GDA_CmdParameterSeq;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CmdParameterSeq_0</NAME>
#define TC_IMPL_TC_GDA_CmdParameterSeq_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CmdParameterSeq_1</NAME>
#define TC_IMPL_TC_GDA_CmdParameterSeq_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CmdParameterSeq_2</NAME>
#define TC_IMPL_TC_GDA_CmdParameterSeq_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_CmdParameterSeq</NAME>
#define TC_GDA_CmdParameterSeq ((CORBA_TypeCode)&TC_GDA_CmdParameterSeq_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_CmdParameterSeq__alloc</NAME>
<RETURNS>GDA_CmdParameterSeq*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_CmdParameterSeq__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>GDA_CMD_NORECORDS</NAME>
#define GDA_CMD_NORECORDS 2147483648
</MACRO>
<ENUM>
<NAME>GDA_CommandType</NAME>
typedef enum {
  GDA_COMMAND_TYPE_TEXT,
  GDA_COMMAND_TYPE_TABLE,
  GDA_COMMAND_TYPE_TABLEDIRECT,
  GDA_COMMAND_TYPE_STOREDPROCEDURE,
  GDA_COMMAND_TYPE_FILE,
  GDA_COMMAND_TYPE_XML
} GDA_CommandType;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CommandType_0</NAME>
#define TC_IMPL_TC_GDA_CommandType_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CommandType_1</NAME>
#define TC_IMPL_TC_GDA_CommandType_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CommandType_2</NAME>
#define TC_IMPL_TC_GDA_CommandType_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_CommandType</NAME>
#define TC_GDA_CommandType ((CORBA_TypeCode)&TC_GDA_CommandType_struct)
</MACRO>
<MACRO>
<NAME>ORBIT_DECL_GDA_Command</NAME>
#define ORBIT_DECL_GDA_Command 1
</MACRO>
<MACRO>
<NAME>GDA_Command__free</NAME>
#define GDA_Command__free CORBA_Object__free
</MACRO>
<TYPEDEF>
<NAME>GDA_Command</NAME>
typedef CORBA_Object GDA_Command;
</TYPEDEF>
<VARIABLE>
<NAME>GDA_Command__classid</NAME>
extern CORBA_unsigned_long GDA_Command__classid;
</VARIABLE>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Command_0</NAME>
#define TC_IMPL_TC_GDA_Command_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Command_1</NAME>
#define TC_IMPL_TC_GDA_Command_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Command_2</NAME>
#define TC_IMPL_TC_GDA_Command_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Command</NAME>
#define TC_GDA_Command ((CORBA_TypeCode)&TC_GDA_Command_struct)
</MACRO>
<ENUM>
<NAME>GDA_CursorLocation</NAME>
typedef enum {
  GDA_USE_CLIENT_CURSOR,
  GDA_USE_SERVER_CURSOR
} GDA_CursorLocation;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CursorLocation_0</NAME>
#define TC_IMPL_TC_GDA_CursorLocation_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CursorLocation_1</NAME>
#define TC_IMPL_TC_GDA_CursorLocation_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_CursorLocation_2</NAME>
#define TC_IMPL_TC_GDA_CursorLocation_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_CursorLocation</NAME>
#define TC_GDA_CursorLocation ((CORBA_TypeCode)&TC_GDA_CursorLocation_struct)
</MACRO>
<MACRO>
<NAME>ORBIT_DECL_GDA_Connection</NAME>
#define ORBIT_DECL_GDA_Connection 1
</MACRO>
<MACRO>
<NAME>GDA_Connection__free</NAME>
#define GDA_Connection__free CORBA_Object__free
</MACRO>
<TYPEDEF>
<NAME>GDA_Connection</NAME>
typedef CORBA_Object GDA_Connection;
</TYPEDEF>
<VARIABLE>
<NAME>GDA_Connection__classid</NAME>
extern CORBA_unsigned_long GDA_Connection__classid;
</VARIABLE>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_0</NAME>
#define TC_IMPL_TC_GDA_Connection_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_1</NAME>
#define TC_IMPL_TC_GDA_Connection_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_2</NAME>
#define TC_IMPL_TC_GDA_Connection_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Connection</NAME>
#define TC_GDA_Connection ((CORBA_TypeCode)&TC_GDA_Connection_struct)
</MACRO>
<ENUM>
<NAME>GDA_Connection_QType</NAME>
typedef enum {
  GDA_Connection_GDCN_SCHEMA_AGGREGATES,
  GDA_Connection_GDCN_SCHEMA_ASSERTS,
  GDA_Connection_GDCN_SCHEMA_CATALOGS,
  GDA_Connection_GDCN_SCHEMA_CHARSETS,
  GDA_Connection_GDCN_SCHEMA_CHECK_CONSTRAINTS,
  GDA_Connection_GDCN_SCHEMA_COLLATIONS,
  GDA_Connection_GDCN_SCHEMA_COL_DOM_USAGE,
  GDA_Connection_GDCN_SCHEMA_COL_PRIVS,
  GDA_Connection_GDCN_SCHEMA_COLS,
  GDA_Connection_GDCN_SCHEMA_CONSTR_COL_USAGE,
  GDA_Connection_GDCN_SCHEMA_CONSTR_TAB_USAGE,
  GDA_Connection_GDCN_SCHEMA_FOREIGN_KEYS,
  GDA_Connection_GDCN_SCHEMA_INDEXES,
  GDA_Connection_GDCN_SCHEMA_INDEX_COLS,
  GDA_Connection_GDCN_SCHEMA_KEY_COL_USAGE,
  GDA_Connection_GDCN_SCHEMA_PRIM_KEYS,
  GDA_Connection_GDCN_SCHEMA_PROC_COLUMNS,
  GDA_Connection_GDCN_SCHEMA_PROC_PARAMS,
  GDA_Connection_GDCN_SCHEMA_PROCS,
  GDA_Connection_GDCN_SCHEMA_PROV_SPEC,
  GDA_Connection_GDCN_SCHEMA_PROV_TYPES,
  GDA_Connection_GDCN_SCHEMA_REF_CONSTRAINTS,
  GDA_Connection_GDCN_SCHEMA_SEQUENCES,
  GDA_Connection_GDCN_SCHEMA_SQL_LANG,
  GDA_Connection_GDCN_SCHEMA_STATISTICS,
  GDA_Connection_GDCN_SCHEMA_TAB_CONSTRAINTS,
  GDA_Connection_GDCN_SCHEMA_TAB_PARENTS,
  GDA_Connection_GDCN_SCHEMA_TAB_PRIVS,
  GDA_Connection_GDCN_SCHEMA_TABLES,
  GDA_Connection_GDCN_SCHEMA_TRANSLATIONS,
  GDA_Connection_GDCN_SCHEMA_USAGE_PROVS,
  GDA_Connection_GDCN_SCHEMA_VIEW_COL_USAGE,
  GDA_Connection_GDCN_SCHEMA_VIEW_TAB_USAGE,
  GDA_Connection_GDCN_SCHEMA_VIEWS,
  GDA_Connection_GDCN_SCHEMA_LAST
} GDA_Connection_QType;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_QType_0</NAME>
#define TC_IMPL_TC_GDA_Connection_QType_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_QType_1</NAME>
#define TC_IMPL_TC_GDA_Connection_QType_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_QType_2</NAME>
#define TC_IMPL_TC_GDA_Connection_QType_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Connection_QType</NAME>
#define TC_GDA_Connection_QType ((CORBA_TypeCode)&TC_GDA_Connection_QType_struct)
</MACRO>
<ENUM>
<NAME>GDA_Connection_ConstraintType</NAME>
typedef enum {
  GDA_Connection_no_CONSTRAINT,
  GDA_Connection_OBJECT_CATALOG,
  GDA_Connection_OBJECT_SCHEMA,
  GDA_Connection_OBJECT_NAME,
  GDA_Connection_TABLE_TYPE,
  GDA_Connection_COLUMN_NAME,
  GDA_Connection_INDEX_NAME,
  GDA_Connection_TYPE,
  GDA_Connection_EXTRA_INFO
} GDA_Connection_ConstraintType;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_ConstraintType_0</NAME>
#define TC_IMPL_TC_GDA_Connection_ConstraintType_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_ConstraintType_1</NAME>
#define TC_IMPL_TC_GDA_Connection_ConstraintType_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_ConstraintType_2</NAME>
#define TC_IMPL_TC_GDA_Connection_ConstraintType_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Connection_ConstraintType</NAME>
#define TC_GDA_Connection_ConstraintType ((CORBA_TypeCode)&TC_GDA_Connection_ConstraintType_struct)
</MACRO>
<ENUM>
<NAME>GDA_Connection_Permission</NAME>
typedef enum {
  GDA_Connection_PERM_UNKNOWN,
  GDA_Connection_PERM_READ,
  GDA_Connection_PERM_WRITE,
  GDA_Connection_PERM_RW,
  GDA_Connection_PERM_DENY_READ,
  GDA_Connection_PERM_DENY_WRITE,
  GDA_Connection_PERM_EXCLUSIVE
} GDA_Connection_Permission;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Permission_0</NAME>
#define TC_IMPL_TC_GDA_Connection_Permission_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Permission_1</NAME>
#define TC_IMPL_TC_GDA_Connection_Permission_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Permission_2</NAME>
#define TC_IMPL_TC_GDA_Connection_Permission_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Connection_Permission</NAME>
#define TC_GDA_Connection_Permission ((CORBA_TypeCode)&TC_GDA_Connection_Permission_struct)
</MACRO>
<ENUM>
<NAME>GDA_Connection_Feature</NAME>
typedef enum {
  GDA_Connection_FEATURE_FOREIGN_KEYS,
  GDA_Connection_FEATURE_INHERITANCE,
  GDA_Connection_FEATURE_OBJECT_ID,
  GDA_Connection_FEATURE_PROCS,
  GDA_Connection_FEATURE_SEQUENCES,
  GDA_Connection_FEATURE_SQL,
  GDA_Connection_FEATURE_SQL_SUBSELECT,
  GDA_Connection_FEATURE_TRANSACTIONS,
  GDA_Connection_FEATURE_TRIGGERS,
  GDA_Connection_FEATURE_VIEWS,
  GDA_Connection_FEATURE_XML_QUERIES
} GDA_Connection_Feature;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Feature_0</NAME>
#define TC_IMPL_TC_GDA_Connection_Feature_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Feature_1</NAME>
#define TC_IMPL_TC_GDA_Connection_Feature_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Feature_2</NAME>
#define TC_IMPL_TC_GDA_Connection_Feature_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Connection_Feature</NAME>
#define TC_GDA_Connection_Feature ((CORBA_TypeCode)&TC_GDA_Connection_Feature_struct)
</MACRO>
<STRUCT>
<NAME>GDA_Connection_Constraint</NAME>
typedef struct {
GDA_Connection_ConstraintType ctype;
CORBA_char * value;
} GDA_Connection_Constraint;
</STRUCT>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Constraint_0</NAME>
#define TC_IMPL_TC_GDA_Connection_Constraint_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Constraint_1</NAME>
#define TC_IMPL_TC_GDA_Connection_Constraint_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_Constraint_2</NAME>
#define TC_IMPL_TC_GDA_Connection_Constraint_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Connection_Constraint</NAME>
#define TC_GDA_Connection_Constraint ((CORBA_TypeCode)&TC_GDA_Connection_Constraint_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Connection_Constraint__alloc</NAME>
<RETURNS>GDA_Connection_Constraint*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_Constraint__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<MACRO>
<NAME>ORBIT_DECL_CORBA_sequence_GDA_Connection_Constraint</NAME>
#define ORBIT_DECL_CORBA_sequence_GDA_Connection_Constraint 1
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_0</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_0 'G'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_1</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_1 'D'
</MACRO>
<MACRO>
<NAME>ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_2</NAME>
#define ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_2 'A'
</MACRO>
<STRUCT>
<NAME>CORBA_sequence_GDA_Connection_Constraint</NAME>
typedef struct { CORBA_unsigned_long _maximum, _length; GDA_Connection_Constraint* _buffer; CORBA_boolean _release; } CORBA_sequence_GDA_Connection_Constraint;
</STRUCT>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Connection_Constraint_allocbuf</NAME>
<RETURNS>GDA_Connection_Constraint *</RETURNS>
CORBA_unsigned_long len
</FUNCTION>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_0</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_1</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_2</NAME>
#define TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_2 'A'
</MACRO>
<MACRO>
<NAME>TC_CORBA_sequence_GDA_Connection_Constraint</NAME>
#define TC_CORBA_sequence_GDA_Connection_Constraint ((CORBA_TypeCode)&TC_CORBA_sequence_GDA_Connection_Constraint_struct)
</MACRO>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Connection_Constraint__alloc</NAME>
<RETURNS>CORBA_sequence_GDA_Connection_Constraint*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>CORBA_sequence_GDA_Connection_Constraint__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<TYPEDEF>
<NAME>GDA_Connection_ConstraintSeq</NAME>
typedef CORBA_sequence_GDA_Connection_Constraint GDA_Connection_ConstraintSeq;
</TYPEDEF>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_ConstraintSeq_0</NAME>
#define TC_IMPL_TC_GDA_Connection_ConstraintSeq_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_ConstraintSeq_1</NAME>
#define TC_IMPL_TC_GDA_Connection_ConstraintSeq_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_Connection_ConstraintSeq_2</NAME>
#define TC_IMPL_TC_GDA_Connection_ConstraintSeq_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_Connection_ConstraintSeq</NAME>
#define TC_GDA_Connection_ConstraintSeq ((CORBA_TypeCode)&TC_GDA_Connection_ConstraintSeq_struct)
</MACRO>
<FUNCTION>
<NAME>GDA_Connection_ConstraintSeq__alloc</NAME>
<RETURNS>GDA_Connection_ConstraintSeq*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_ConstraintSeq__free</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem, gpointer dat, CORBA_boolean free_strings
</FUNCTION>
<ENUM>
<NAME>GDA_AffectedRows</NAME>
typedef enum {
  GDA_GDR_AFFECT_CURRENT,
  GDA_GDR_AFFECT_GROUP,
  GDA_GDR_AFFECT_ALL
} GDA_AffectedRows;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_AffectedRows_0</NAME>
#define TC_IMPL_TC_GDA_AffectedRows_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_AffectedRows_1</NAME>
#define TC_IMPL_TC_GDA_AffectedRows_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_AffectedRows_2</NAME>
#define TC_IMPL_TC_GDA_AffectedRows_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_AffectedRows</NAME>
#define TC_GDA_AffectedRows ((CORBA_TypeCode)&TC_GDA_AffectedRows_struct)
</MACRO>
<ENUM>
<NAME>GDA_IsolationLevel</NAME>
typedef enum {
  GDA_IL_UNSPECIFIED,
  GDA_IL_CHAOS,
  GDA_IL_BROWSE,
  GDA_IL_READ_COMMITED,
  GDA_IL_READ_INCOMMTED,
  GDA_IL_READ_REPEATED,
  GDA_IL_READ_SERIALIZABLE
} GDA_IsolationLevel;
</ENUM>
<MACRO>
<NAME>TC_IMPL_TC_GDA_IsolationLevel_0</NAME>
#define TC_IMPL_TC_GDA_IsolationLevel_0 'G'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_IsolationLevel_1</NAME>
#define TC_IMPL_TC_GDA_IsolationLevel_1 'D'
</MACRO>
<MACRO>
<NAME>TC_IMPL_TC_GDA_IsolationLevel_2</NAME>
#define TC_IMPL_TC_GDA_IsolationLevel_2 'A'
</MACRO>
<MACRO>
<NAME>TC_GDA_IsolationLevel</NAME>
#define TC_GDA_IsolationLevel ((CORBA_TypeCode)&TC_GDA_IsolationLevel_struct)
</MACRO>
<STRUCT>
<NAME>POA_GDA_Listener__epv</NAME>
typedef struct {
  void *_private;
void (*notifyAction)(PortableServer_Servant _servant, const CORBA_char * message, const GDA_ListenerAction action, const CORBA_char * description, CORBA_Environment *ev);
} POA_GDA_Listener__epv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Listener__vepv</NAME>
typedef struct {
  PortableServer_ServantBase__epv *_base_epv;
  POA_Bonobo_Unknown__epv *Bonobo_Unknown_epv;
  POA_GDA_Listener__epv *GDA_Listener_epv;
} POA_GDA_Listener__vepv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Listener</NAME>
typedef struct {
  void *_private;
  POA_GDA_Listener__vepv *vepv;
} POA_GDA_Listener;
</STRUCT>
<FUNCTION>
<NAME>POA_GDA_Listener__init</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>POA_GDA_Listener__fini</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<STRUCT>
<NAME>POA_GDA_Recordset__epv</NAME>
typedef struct {
  void *_private;
CORBA_long (*getRowCount)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*close)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*moveFirst)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*moveLast)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*moveNext)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*movePrev)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*reQuery)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_boolean (*supports)(PortableServer_Servant _servant, const GDA_Option what, CORBA_Environment *ev);
GDA_Recordset_Chunk* (*fetch)(PortableServer_Servant _servant, const CORBA_long count, CORBA_Environment *ev);
GDA_RowAttributes* (*describe)(PortableServer_Servant _servant, CORBA_Environment *ev);
} POA_GDA_Recordset__epv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Recordset__vepv</NAME>
typedef struct {
  PortableServer_ServantBase__epv *_base_epv;
  POA_Bonobo_Unknown__epv *Bonobo_Unknown_epv;
  POA_GDA_Recordset__epv *GDA_Recordset_epv;
} POA_GDA_Recordset__vepv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Recordset</NAME>
typedef struct {
  void *_private;
  POA_GDA_Recordset__vepv *vepv;
} POA_GDA_Recordset;
</STRUCT>
<FUNCTION>
<NAME>POA_GDA_Recordset__init</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>POA_GDA_Recordset__fini</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<STRUCT>
<NAME>POA_GDA_Parameter__epv</NAME>
typedef struct {
  void *_private;
CORBA_long (*appendChunk)(PortableServer_Servant _servant, const GDA_Parameter_VarBinString* data, CORBA_Environment *ev);
} POA_GDA_Parameter__epv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Parameter__vepv</NAME>
typedef struct {
  PortableServer_ServantBase__epv *_base_epv;
  POA_GDA_Parameter__epv *GDA_Parameter_epv;
} POA_GDA_Parameter__vepv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Parameter</NAME>
typedef struct {
  void *_private;
  POA_GDA_Parameter__vepv *vepv;
} POA_GDA_Parameter;
</STRUCT>
<FUNCTION>
<NAME>POA_GDA_Parameter__init</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>POA_GDA_Parameter__fini</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<STRUCT>
<NAME>POA_GDA_Command__epv</NAME>
typedef struct {
  void *_private;
CORBA_char * (*_get_text)(PortableServer_Servant _servant, CORBA_Environment *ev);
void (*_set_text)(PortableServer_Servant _servant, const CORBA_char * value, CORBA_Environment *ev);
GDA_CommandType (*_get_type)(PortableServer_Servant _servant, CORBA_Environment *ev);
void (*_set_type)(PortableServer_Servant _servant, const GDA_CommandType value, CORBA_Environment *ev);
GDA_Recordset (*open)(PortableServer_Servant _servant, const GDA_CmdParameterSeq* param, const GDA_CursorType ct, const GDA_LockType lt, CORBA_unsigned_long* affected, CORBA_Environment *ev);
} POA_GDA_Command__epv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Command__vepv</NAME>
typedef struct {
  PortableServer_ServantBase__epv *_base_epv;
  POA_Bonobo_Unknown__epv *Bonobo_Unknown_epv;
  POA_GDA_Command__epv *GDA_Command_epv;
} POA_GDA_Command__vepv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Command</NAME>
typedef struct {
  void *_private;
  POA_GDA_Command__vepv *vepv;
} POA_GDA_Command;
</STRUCT>
<FUNCTION>
<NAME>POA_GDA_Command__init</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>POA_GDA_Command__fini</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<STRUCT>
<NAME>POA_GDA_Connection__epv</NAME>
typedef struct {
  void *_private;
CORBA_char * (*_get_version)(PortableServer_Servant _servant, CORBA_Environment *ev);
GDA_ErrorSeq* (*_get_errors)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*beginTransaction)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*commitTransaction)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*rollbackTransaction)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*close)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*open)(PortableServer_Servant _servant, const CORBA_char * dsn, const CORBA_char * user, const CORBA_char * passwd, CORBA_Environment *ev);
GDA_Recordset (*openSchema)(PortableServer_Servant _servant, const GDA_Connection_QType t, const GDA_Connection_ConstraintSeq* constraints, CORBA_Environment *ev);
CORBA_long (*modifySchema)(PortableServer_Servant _servant, const GDA_Connection_QType t, const GDA_Connection_ConstraintSeq* constraints, CORBA_Environment *ev);
GDA_Command (*createCommand)(PortableServer_Servant _servant, CORBA_Environment *ev);
GDA_Recordset (*createRecordset)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_long (*startLogging)(PortableServer_Servant _servant, const CORBA_char * filename, CORBA_Environment *ev);
CORBA_long (*stopLogging)(PortableServer_Servant _servant, CORBA_Environment *ev);
CORBA_char * (*createTable)(PortableServer_Servant _servant, const CORBA_char * name, const GDA_RowAttributes* columns, CORBA_Environment *ev);
CORBA_boolean (*supports)(PortableServer_Servant _servant, const GDA_Connection_Feature feature, CORBA_Environment *ev);
CORBA_char * (*sql2xml)(PortableServer_Servant _servant, const CORBA_char * sql, CORBA_Environment *ev);
CORBA_char * (*xml2sql)(PortableServer_Servant _servant, const CORBA_char * xml, CORBA_Environment *ev);
void (*addListener)(PortableServer_Servant _servant, const GDA_Listener listener, CORBA_Environment *ev);
void (*removeListener)(PortableServer_Servant _servant, const GDA_Listener listener, CORBA_Environment *ev);
} POA_GDA_Connection__epv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Connection__vepv</NAME>
typedef struct {
  PortableServer_ServantBase__epv *_base_epv;
  POA_Bonobo_Unknown__epv *Bonobo_Unknown_epv;
  POA_GDA_Connection__epv *GDA_Connection_epv;
} POA_GDA_Connection__vepv;
</STRUCT>
<STRUCT>
<NAME>POA_GDA_Connection</NAME>
typedef struct {
  void *_private;
  POA_GDA_Connection__vepv *vepv;
} POA_GDA_Connection;
</STRUCT>
<FUNCTION>
<NAME>POA_GDA_Connection__init</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>POA_GDA_Connection__fini</NAME>
<RETURNS>void </RETURNS>
PortableServer_Servant servant, CORBA_Environment *ev
</FUNCTION>
<MACRO>
<NAME>GDA_Listener_ref</NAME>
#define GDA_Listener_ref Bonobo_Unknown_ref
</MACRO>
<MACRO>
<NAME>GDA_Listener_unref</NAME>
#define GDA_Listener_unref Bonobo_Unknown_unref
</MACRO>
<MACRO>
<NAME>GDA_Listener_queryInterface</NAME>
#define GDA_Listener_queryInterface Bonobo_Unknown_queryInterface
</MACRO>
<FUNCTION>
<NAME>GDA_Listener_notifyAction</NAME>
<RETURNS>void </RETURNS>
GDA_Listener _obj, const CORBA_char * message, const GDA_ListenerAction action, const CORBA_char * description, CORBA_Environment *ev
</FUNCTION>
<MACRO>
<NAME>GDA_Recordset_ref</NAME>
#define GDA_Recordset_ref Bonobo_Unknown_ref
</MACRO>
<MACRO>
<NAME>GDA_Recordset_unref</NAME>
#define GDA_Recordset_unref Bonobo_Unknown_unref
</MACRO>
<MACRO>
<NAME>GDA_Recordset_queryInterface</NAME>
#define GDA_Recordset_queryInterface Bonobo_Unknown_queryInterface
</MACRO>
<FUNCTION>
<NAME>GDA_Recordset_getRowCount</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_close</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_moveFirst</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_moveLast</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_moveNext</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_movePrev</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_reQuery</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_supports</NAME>
<RETURNS>CORBA_boolean </RETURNS>
GDA_Recordset _obj, const GDA_Option what, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_fetch</NAME>
<RETURNS>GDA_Recordset_Chunk*</RETURNS>
GDA_Recordset _obj, const CORBA_long count, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Recordset_describe</NAME>
<RETURNS>GDA_RowAttributes*</RETURNS>
GDA_Recordset _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Parameter_appendChunk</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Parameter _obj, const GDA_Parameter_VarBinString* data, CORBA_Environment *ev
</FUNCTION>
<MACRO>
<NAME>GDA_Command_ref</NAME>
#define GDA_Command_ref Bonobo_Unknown_ref
</MACRO>
<MACRO>
<NAME>GDA_Command_unref</NAME>
#define GDA_Command_unref Bonobo_Unknown_unref
</MACRO>
<MACRO>
<NAME>GDA_Command_queryInterface</NAME>
#define GDA_Command_queryInterface Bonobo_Unknown_queryInterface
</MACRO>
<FUNCTION>
<NAME>GDA_Command__get_text</NAME>
<RETURNS>CORBA_char *</RETURNS>
GDA_Command _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Command__set_text</NAME>
<RETURNS>void </RETURNS>
GDA_Command _obj, const CORBA_char * value, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Command__get_type</NAME>
<RETURNS>GDA_CommandType </RETURNS>
GDA_Command _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Command__set_type</NAME>
<RETURNS>void </RETURNS>
GDA_Command _obj, const GDA_CommandType value, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Command_open</NAME>
<RETURNS>GDA_Recordset </RETURNS>
GDA_Command _obj, const GDA_CmdParameterSeq* param, const GDA_CursorType ct, const GDA_LockType lt, CORBA_unsigned_long* affected, CORBA_Environment *ev
</FUNCTION>
<MACRO>
<NAME>GDA_Connection_ref</NAME>
#define GDA_Connection_ref Bonobo_Unknown_ref
</MACRO>
<MACRO>
<NAME>GDA_Connection_unref</NAME>
#define GDA_Connection_unref Bonobo_Unknown_unref
</MACRO>
<MACRO>
<NAME>GDA_Connection_queryInterface</NAME>
#define GDA_Connection_queryInterface Bonobo_Unknown_queryInterface
</MACRO>
<FUNCTION>
<NAME>GDA_Connection__get_version</NAME>
<RETURNS>CORBA_char *</RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection__get_errors</NAME>
<RETURNS>GDA_ErrorSeq*</RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_beginTransaction</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_commitTransaction</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_rollbackTransaction</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_close</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_open</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, const CORBA_char * dsn, const CORBA_char * user, const CORBA_char * passwd, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_openSchema</NAME>
<RETURNS>GDA_Recordset </RETURNS>
GDA_Connection _obj, const GDA_Connection_QType t, const GDA_Connection_ConstraintSeq* constraints, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_modifySchema</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, const GDA_Connection_QType t, const GDA_Connection_ConstraintSeq* constraints, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_createCommand</NAME>
<RETURNS>GDA_Command </RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_createRecordset</NAME>
<RETURNS>GDA_Recordset </RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_startLogging</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, const CORBA_char * filename, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_stopLogging</NAME>
<RETURNS>CORBA_long </RETURNS>
GDA_Connection _obj, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_createTable</NAME>
<RETURNS>CORBA_char *</RETURNS>
GDA_Connection _obj, const CORBA_char * name, const GDA_RowAttributes* columns, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_supports</NAME>
<RETURNS>CORBA_boolean </RETURNS>
GDA_Connection _obj, const GDA_Connection_Feature feature, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_sql2xml</NAME>
<RETURNS>CORBA_char *</RETURNS>
GDA_Connection _obj, const CORBA_char * sql, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_xml2sql</NAME>
<RETURNS>CORBA_char *</RETURNS>
GDA_Connection _obj, const CORBA_char * xml, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_addListener</NAME>
<RETURNS>void </RETURNS>
GDA_Connection _obj, const GDA_Listener listener, CORBA_Environment *ev
</FUNCTION>
<FUNCTION>
<NAME>GDA_Connection_removeListener</NAME>
<RETURNS>void </RETURNS>
GDA_Connection _obj, const GDA_Listener listener, CORBA_Environment *ev
</FUNCTION>
