gda-attributes-manager.h   gda-attributes-manager.h 
skipping to change at line 28 skipping to change at line 28
*/ */
#ifndef __GDA_ATTRIBUTES_MANAGER_H__ #ifndef __GDA_ATTRIBUTES_MANAGER_H__
#define __GDA_ATTRIBUTES_MANAGER_H__ #define __GDA_ATTRIBUTES_MANAGER_H__
#include <glib-object.h> #include <glib-object.h>
G_BEGIN_DECLS G_BEGIN_DECLS
/* main struct */ /* main struct */
/**
* GdaAttributesManager: (skip)
*/
typedef struct _GdaAttributesManager GdaAttributesManager; typedef struct _GdaAttributesManager GdaAttributesManager;
typedef void (*GdaAttributesManagerFunc) (const gchar *att_name, const GVal ue *value, gpointer data); typedef void (*GdaAttributesManagerFunc) (const gchar *att_name, const GVal ue *value, gpointer data);
typedef void (*GdaAttributesManagerSignal) (GObject *obj, const gchar *att_ name, const GValue *value, gpointer data); typedef void (*GdaAttributesManagerSignal) (GObject *obj, const gchar *att_ name, const GValue *value, gpointer data);
GdaAttributesManager *gda_attributes_manager_new (gboolean for_obje cts, GdaAttributesManager *gda_attributes_manager_new (gboolean for_obje cts,
GdaAttributesManag erSignal signal_func, gpointer signal_data); GdaAttributesManag erSignal signal_func, gpointer signal_data);
void gda_attributes_manager_free (GdaAttributesMana ger *mgr); void gda_attributes_manager_free (GdaAttributesMana ger *mgr);
void gda_attributes_manager_set (GdaAttributesMana ger *mgr, gpointer ptr, void gda_attributes_manager_set (GdaAttributesMana ger *mgr, gpointer ptr,
const gchar *att_n ame, const GValue *value); const gchar *att_n ame, const GValue *value);
 End of changes. 1 change blocks. 
0 lines changed or deleted 3 lines changed or added


 gda-data-access-wrapper.h   gda-data-access-wrapper.h 
skipping to change at line 61 skipping to change at line 61
void (*_gda_reserved4) (void); void (*_gda_reserved4) (void);
}; };
/** /**
* SECTION:gda-data-access-wrapper * SECTION:gda-data-access-wrapper
* @short_description: Offers a random access on top of a cursor-only acces s data model * @short_description: Offers a random access on top of a cursor-only acces s data model
* @title: GdaDataAccessWrapper * @title: GdaDataAccessWrapper
* @stability: Stable * @stability: Stable
* @see_also: #GdaDataModel * @see_also: #GdaDataModel
* *
* The #GdaDataAccessWrapper object simply wraps around another #GdaDataMod el data model object * The #GdaDataAccessWrapper object simply wraps another #GdaDataModel data model object
* and allows data to be accessed in a random way while remaining memory ef ficient as much as possible. * and allows data to be accessed in a random way while remaining memory ef ficient as much as possible.
*/ */
GType gda_data_access_wrapper_get_type (void) G_GNUC_CONST; GType gda_data_access_wrapper_get_type (void) G_GNUC_CONST;
GdaDataModel *gda_data_access_wrapper_new (GdaDataModel *model); GdaDataModel *gda_data_access_wrapper_new (GdaDataModel *model);
gboolean gda_data_access_wrapper_set_mapping (GdaDataAccessWrapper *wr
apper,
gint *mapping, gint mappi
ng_size);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 2 change blocks. 
1 lines changed or deleted 5 lines changed or added


 gda-data-model-array.h   gda-data-model-array.h 
skipping to change at line 76 skipping to change at line 76
* of rows is huge. * of rows is huge.
* This type of data model is easy to use to store some temporary data, and has a random access mode (any value can be accessed * This type of data model is easy to use to store some temporary data, and has a random access mode (any value can be accessed
* at any time without the need for an iterator). * at any time without the need for an iterator).
*/ */
GType gda_data_model_array_get_type (void) G_GNUC_CON ST; GType gda_data_model_array_get_type (void) G_GNUC_CON ST;
GdaDataModel *gda_data_model_array_new_with_g_types (gint cols, ...); GdaDataModel *gda_data_model_array_new_with_g_types (gint cols, ...);
GdaDataModel *gda_data_model_array_new_with_g_types_v (gint cols, GTyp e *types); GdaDataModel *gda_data_model_array_new_with_g_types_v (gint cols, GTyp e *types);
GdaDataModel *gda_data_model_array_new (gint cols); GdaDataModel *gda_data_model_array_new (gint cols);
GdaDataModelArray *gda_data_model_array_copy_model (GdaDataModel *sr c, GError **error); GdaDataModelArray *gda_data_model_array_copy_model (GdaDataModel *sr c, GError **error);
GdaDataModelArray *gda_data_model_array_copy_model_ext (GdaDataModel *sr
c,
gint ncols, gint
*cols, GError **error);
GdaRow *gda_data_model_array_get_row (GdaDataModelArra y *model, gint row, GError **error); GdaRow *gda_data_model_array_get_row (GdaDataModelArra y *model, gint row, GError **error);
void gda_data_model_array_set_n_columns (GdaDataModelArra y *model, gint cols); void gda_data_model_array_set_n_columns (GdaDataModelArra y *model, gint cols);
void gda_data_model_array_clear (GdaDataModelArra y *model); void gda_data_model_array_clear (GdaDataModelArra y *model);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 1 change blocks. 
0 lines changed or deleted 4 lines changed or added


 gda-data-model-iter.h   gda-data-model-iter.h 
skipping to change at line 112 skipping to change at line 112
* <imagedata fileref="GdaDataModelIter.png" format="PNG" contentwidth= "190mm"/> * <imagedata fileref="GdaDataModelIter.png" format="PNG" contentwidth= "190mm"/>
* </imageobject> * </imageobject>
* <textobject> * <textobject>
* <phrase>GdaDataModelIter's usage</phrase> * <phrase>GdaDataModelIter's usage</phrase>
* </textobject> * </textobject>
* </mediaobject> * </mediaobject>
* *
* Note: the new #GdaDataModelIter does not hold any reference to the data model it iterates through (ie. * Note: the new #GdaDataModelIter does not hold any reference to the data model it iterates through (ie.
* if this data model is destroyed at some point, the new iterator will bec ome useless but in * if this data model is destroyed at some point, the new iterator will bec ome useless but in
* any case it will not prevent the data model from being destroyed). * any case it will not prevent the data model from being destroyed).
*
* Note: when the data model emits the "reset" signal, then:
* <itemizedlist>
* <listitem><para>the number of columns of the iterator can change to ref
lect the new data model
* being itered on. In this case the iterator's position is reset as if
it was
* just created</para></listitem>
* <listitem><para>some column types which were unknown (i.e. GDA_TYPE_NUL
L type), can change
* to their correct type. In this case there is no other iterator change
</para></listitem>
* <listitem><para>some column types which were not GDA_TYPE_NULL can chan
ge, and in this case
* the iterator's position is reset as if it was just created</para></li
stitem>
* </itemizedlist>
*/ */
GType gda_data_model_iter_get_type (void) G_GNUC_CO NST; GType gda_data_model_iter_get_type (void) G_GNUC_CO NST;
const GValue *gda_data_model_iter_get_value_at (GdaDataModelIte r *iter, gint col); const GValue *gda_data_model_iter_get_value_at (GdaDataModelIte r *iter, gint col);
const GValue *gda_data_model_iter_get_value_at_e (GdaDataModelIte r *iter, gint col, GError **error); const GValue *gda_data_model_iter_get_value_at_e (GdaDataModelIte r *iter, gint col, GError **error);
const GValue *gda_data_model_iter_get_value_for_field (GdaDataModelIte r *iter, const gchar *field_name); const GValue *gda_data_model_iter_get_value_for_field (GdaDataModelIte r *iter, const gchar *field_name);
gboolean gda_data_model_iter_set_value_at (GdaDataModelIte r *iter, gint col, gboolean gda_data_model_iter_set_value_at (GdaDataModelIte r *iter, gint col,
const GValue *va lue, GError **error); const GValue *va lue, GError **error);
 End of changes. 1 change blocks. 
0 lines changed or deleted 17 lines changed or added


 gda-data-model-ldap.h   gda-data-model-ldap.h 
skipping to change at line 80 skipping to change at line 80
* @title: GdaDataModelLdap * @title: GdaDataModelLdap
* @stability: Unstable * @stability: Unstable
* @see_also: #GdaDataModel * @see_also: #GdaDataModel
* *
* The #GdaDataModelLdap object allows to perform LDAP searches. * The #GdaDataModelLdap object allows to perform LDAP searches.
* *
* Note: this type of data model is available only if the LDAP library was found at compilation time and * Note: this type of data model is available only if the LDAP library was found at compilation time and
* if the LDAP provider is correctly installed. * if the LDAP provider is correctly installed.
*/ */
GType gda_data_model_ldap_get_type (void) G_GNUC_CONST; GType gda_data_model_ldap_get_type (void) G_GNUC_CONST;
GdaDataModel *gda_data_model_ldap_new (GdaConnection *cnc, GdaDataModel *gda_data_model_ldap_new (GdaConnection *cnc,
const gchar *base_dn, const const gchar *base_dn
gchar *filter, , const gchar *filter,
const gchar *attributes, Gda const gchar *attribu
LdapSearchScope scope); tes, GdaLdapSearchScope scope);
GdaDataModelLdap *gda_data_model_ldap_new_with_config (GdaConnection *cnc,
const gchar *base_dn
, const gchar *filter,
const gchar *attribu
tes, GdaLdapSearchScope scope);
GList *gda_data_model_ldap_compute_columns (GdaConnection *cnc, cons t gchar *attributes); GList *gda_data_model_ldap_compute_columns (GdaConnection *cnc, const gchar *attributes);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 2 change blocks. 
7 lines changed or deleted 12 lines changed or added


 gda-data-model.h   gda-data-model.h 
skipping to change at line 168 skipping to change at line 168
* Thus if a data model must handle large quantities of data, it is general ly wiser to use a data model which can be * Thus if a data model must handle large quantities of data, it is general ly wiser to use a data model which can be
* only accessed using a cursor. * only accessed using a cursor.
* *
* As a side note there are also data models which wrap other data models s uch as: * As a side note there are also data models which wrap other data models s uch as:
* <itemizedlist> * <itemizedlist>
* <listitem><para>The #GdaDataProxy data model which stores temporary modifications and shows only some * <listitem><para>The #GdaDataProxy data model which stores temporary modifications and shows only some
* parts of the wrapped data model</para></listitem> * parts of the wrapped data model</para></listitem>
* <listitem><para>The #GdaDataAccessWrapper data model which offers a memory efficient random access on top of a * <listitem><para>The #GdaDataAccessWrapper data model which offers a memory efficient random access on top of a
* wrapped cursor based access data model</para></listitem> * wrapped cursor based access data model</para></listitem>
* </itemizedlist> * </itemizedlist>
*
* Also see the section about <link linkend="gda-data-model-writing">writin
g your own GdaDataModel</link>
*/ */
GType gda_data_model_get_type (void) G_GNUC_CON ST; GType gda_data_model_get_type (void) G_GNUC_CON ST;
GdaDataModelAccessFlags gda_data_model_get_access_flags (GdaDataModel *mo del); GdaDataModelAccessFlags gda_data_model_get_access_flags (GdaDataModel *mo del);
gint gda_data_model_get_n_rows (GdaDataModel *mo del); gint gda_data_model_get_n_rows (GdaDataModel *mo del);
gint gda_data_model_get_n_columns (GdaDataModel *mo del); gint gda_data_model_get_n_columns (GdaDataModel *mo del);
GdaColumn *gda_data_model_describe_column (GdaDataModel *mo del, gint col); GdaColumn *gda_data_model_describe_column (GdaDataModel *mo del, gint col);
skipping to change at line 189 skipping to change at line 191
const gchar *gda_data_model_get_column_name (GdaDataModel *mod el, gint col); const gchar *gda_data_model_get_column_name (GdaDataModel *mod el, gint col);
void gda_data_model_set_column_name (GdaDataModel *mod el, gint col, const gchar *name); void gda_data_model_set_column_name (GdaDataModel *mod el, gint col, const gchar *name);
const gchar *gda_data_model_get_column_title (GdaDataModel *mo del, gint col); const gchar *gda_data_model_get_column_title (GdaDataModel *mo del, gint col);
void gda_data_model_set_column_title (GdaDataModel *mo del, gint col, const gchar *title); void gda_data_model_set_column_title (GdaDataModel *mo del, gint col, const gchar *title);
const GValue *gda_data_model_get_value_at (GdaDataModel *mo del, gint col, gint row, GError **error); const GValue *gda_data_model_get_value_at (GdaDataModel *mo del, gint col, gint row, GError **error);
const GValue *gda_data_model_get_typed_value_at (GdaDataModel *mo del, gint col, gint row, const GValue *gda_data_model_get_typed_value_at (GdaDataModel *mo del, gint col, gint row,
GType expected_ty pe, gboolean nullok, GError **error); GType expected_ty pe, gboolean nullok, GError **error);
GdaValueAttribute gda_data_model_get_attributes_at (GdaDataModel *mo del, gint col, gint row); GdaValueAttribute gda_data_model_get_attributes_at (GdaDataModel *mo del, gint col, gint row);
GdaDataModelIter *gda_data_model_create_iter (GdaDataModel *mo del); GdaDataModelIter *gda_data_model_create_iter (GdaDataModel *mo del);
gboolean gda_data_model_iter_at_row (GdaDataModel *mo
del, GdaDataModelIter *iter,
gint row);
gboolean gda_data_model_iter_next (GdaDataModel *mo
del, GdaDataModelIter *iter);
gboolean gda_data_model_iter_prev (GdaDataModel *mo
del, GdaDataModelIter *iter);
gboolean gda_data_model_iter_set_value (GdaDataModel *mo
del, GdaDataModelIter *iter, gint col,
const GValue *value,
GError **error);
void gda_data_model_freeze (GdaDataModel *mo del); void gda_data_model_freeze (GdaDataModel *mo del);
void gda_data_model_thaw (GdaDataModel *mo del); void gda_data_model_thaw (GdaDataModel *mo del);
void gda_data_model_set_notify (GdaDataModel *mo
del, gboolean do_notify_changes);
gboolean gda_data_model_get_notify (GdaDataModel *mo
del);
gboolean gda_data_model_set_value_at (GdaDataModel *mo del, gint col, gint row, gboolean gda_data_model_set_value_at (GdaDataModel *mo del, gint col, gint row,
const GValue *val ue, GError **error); const GValue *val ue, GError **error);
gboolean gda_data_model_set_values (GdaDataModel *mo del, gint row, gboolean gda_data_model_set_values (GdaDataModel *mo del, gint row,
GList *values, GE rror **error); GList *values, GE rror **error);
gint gda_data_model_append_row (GdaDataModel *mo del, GError **error); gint gda_data_model_append_row (GdaDataModel *mo del, GError **error);
gint gda_data_model_append_values (GdaDataModel *mo del, const GList *values, GError **error); gint gda_data_model_append_values (GdaDataModel *mo del, const GList *values, GError **error);
gboolean gda_data_model_remove_row (GdaDataModel *mo del, gint row, GError **error); gboolean gda_data_model_remove_row (GdaDataModel *mo del, gint row, GError **error);
gint gda_data_model_get_row_from_values (GdaDataModel *mo del, GSList *values, gint *cols_index); gint gda_data_model_get_row_from_values (GdaDataModel *mo del, GSList *values, gint *cols_index);
void gda_data_model_send_hint (GdaDataModel *mo del, GdaDataModelHint hint, const GValue *hint_value); void gda_data_model_send_hint (GdaDataModel *mo del, GdaDataModelHint hint, const GValue *hint_value);
 End of changes. 3 change blocks. 
0 lines changed or deleted 18 lines changed or added


 gda-data-proxy.h   gda-data-proxy.h 
skipping to change at line 110 skipping to change at line 110
* </itemizedlist> * </itemizedlist>
* </para> * </para>
* </listitem> * </listitem>
* <listitem><para>a variable number of rows depending on the following attributes: * <listitem><para>a variable number of rows depending on the following attributes:
* <itemizedlist> * <itemizedlist>
* <listitem><para>if the proxy is configured to have an empty row as the first row</para></listitem> * <listitem><para>if the proxy is configured to have an empty row as the first row</para></listitem>
* <listitem><para>if the proxy only displays parts of the proxied da ta model</para></listitem> * <listitem><para>if the proxy only displays parts of the proxied da ta model</para></listitem>
* <listitem><para>if new rows have been added to the proxy</para></l istitem> * <listitem><para>if new rows have been added to the proxy</para></l istitem>
* </itemizedlist> * </itemizedlist>
* </para></listitem> * </para></listitem>
* <listitem><para>Any #GdaDataModelIter iterator created will only make
appear the colmuns as present in the proxied
* data model, not any of the other columns</para></listitem>
* </itemizedlist> * </itemizedlist>
* This situation is illustrated in the following schema, where there is a direct mapping between the proxy's * This situation is illustrated in the following schema, where there is a direct mapping between the proxy's
* rows and the proxied data model's rows: * rows and the proxied data model's rows:
* <mediaobject> * <mediaobject>
* <imageobject role="html"> * <imageobject role="html">
* <imagedata fileref="data_proxy1.png" format="PNG" contentwidth="170 mm"/> * <imagedata fileref="data_proxy1.png" format="PNG" contentwidth="170 mm"/>
* </imageobject> * </imageobject>
* <textobject> * <textobject>
* <phrase>GdaDataProxy's values mapping regarding the proxied data mo del</phrase> * <phrase>GdaDataProxy's values mapping regarding the proxied data mo del</phrase>
* </textobject> * </textobject>
skipping to change at line 182 skipping to change at line 184
* </mediaobject> * </mediaobject>
* </para></listitem> * </para></listitem>
* </itemizedlist> * </itemizedlist>
* *
* The #GdaDataProxy objects are thread safe, which means any proxy object can be used from * The #GdaDataProxy objects are thread safe, which means any proxy object can be used from
* any thread at the same time as they implement their own locking mechani sms. * any thread at the same time as they implement their own locking mechani sms.
*/ */
GType gda_data_proxy_get_type (void) G_GNUC_CON ST; GType gda_data_proxy_get_type (void) G_GNUC_CON ST;
GObject *gda_data_proxy_new (GdaDataModel *mo del); GObject *gda_data_proxy_new (GdaDataModel *mo del);
GdaDataProxy *gda_data_proxy_new_with_data_model (GdaDataModel *mo del);
GdaDataModel *gda_data_proxy_get_proxied_model (GdaDataProxy *pr oxy); GdaDataModel *gda_data_proxy_get_proxied_model (GdaDataProxy *pr oxy);
gint gda_data_proxy_get_proxied_model_n_cols (GdaDataProxy *pr oxy); gint gda_data_proxy_get_proxied_model_n_cols (GdaDataProxy *pr oxy);
gint gda_data_proxy_get_proxied_model_n_rows (GdaDataProxy *pr oxy); gint gda_data_proxy_get_proxied_model_n_rows (GdaDataProxy *pr oxy);
gboolean gda_data_proxy_is_read_only (GdaDataProxy *pr oxy); gboolean gda_data_proxy_is_read_only (GdaDataProxy *pr oxy);
GSList *gda_data_proxy_get_values (GdaDataProxy *pr oxy, gint proxy_row, GSList *gda_data_proxy_get_values (GdaDataProxy *pr oxy, gint proxy_row,
gint *cols_index, gint n_cols); gint *cols_index, gint n_cols);
GdaValueAttribute gda_data_proxy_get_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col); GdaValueAttribute gda_data_proxy_get_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col);
void gda_data_proxy_alter_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col, GdaValueAttribute alter_flags); void gda_data_proxy_alter_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col, GdaValueAttribute alter_flags);
gint gda_data_proxy_get_proxied_model_row (GdaDataProxy *pr oxy, gint proxy_row); gint gda_data_proxy_get_proxied_model_row (GdaDataProxy *pr oxy, gint proxy_row);
 End of changes. 2 change blocks. 
0 lines changed or deleted 4 lines changed or added


 gda-ldap-connection.h   gda-ldap-connection.h 
skipping to change at line 164 skipping to change at line 164
* *
* This structure holds information about the attributes of a single LDAP e ntry. * This structure holds information about the attributes of a single LDAP e ntry.
*/ */
typedef struct { typedef struct {
gchar *dn; gchar *dn;
guint nb_attributes; guint nb_attributes;
GdaLdapAttribute **attributes; GdaLdapAttribute **attributes;
GHashTable *attributes_hash; GHashTable *attributes_hash;
} GdaLdapEntry; } GdaLdapEntry;
GdaLdapEntry *gda_ldap_entry_new (const gchar *dn);
void gda_ldap_entry_add_attribute (GdaLdapEntry *entry, gb
oolean merge, const gchar *attr_name,
guint nb_values, GValue
**values);
void gda_ldap_entry_free (GdaLdapEntry *entry); void gda_ldap_entry_free (GdaLdapEntry *entry);
GdaLdapEntry *gda_ldap_describe_entry (GdaLdapConnection *cnc, const gchar *dn, GError **error); GdaLdapEntry *gda_ldap_describe_entry (GdaLdapConnection *cnc, const gchar *dn, GError **error);
GdaLdapEntry **gda_ldap_get_entry_children (GdaLdapConnection *cnc, const gchar *dn, GdaLdapEntry **gda_ldap_get_entry_children (GdaLdapConnection *cnc, const gchar *dn,
gchar **attributes, GErr or **error); gchar **attributes, GErr or **error);
gchar **gda_ldap_dn_split (const gchar *dn, gboole an all); gchar **gda_ldap_dn_split (const gchar *dn, gboole an all);
gboolean gda_ldap_is_dn (const gchar *dn); gboolean gda_ldap_is_dn (const gchar *dn);
typedef struct {
gchar *name;
GType g_type;
gboolean required;
} GdaLdapAttributeDefinition;
void gda_ldap_attributes_list_free (GSList *list);
GSList *gda_ldap_entry_get_attributes_list (GdaLdapConnection *cnc,
GdaLdapEntry *entry);
/** /**
* GdaLdapClassKind: * GdaLdapClassKind:
* @GDA_LDAP_CLASS_KIND_ABSTRACT: the LDAP class is an abstract class * @GDA_LDAP_CLASS_KIND_ABSTRACT: the LDAP class is an abstract class
* @GDA_LDAP_CLASS_KIND_STRUTURAL: the LDAP class is a structural class * @GDA_LDAP_CLASS_KIND_STRUTURAL: the LDAP class is a structural class
* @GDA_LDAP_CLASS_KIND_AUXILIARY: the LDAP class is auxilliary * @GDA_LDAP_CLASS_KIND_AUXILIARY: the LDAP class is auxilliary
* @GDA_LDAP_CLASS_KIND_UNKNOWN: the LDAP class type is not known * @GDA_LDAP_CLASS_KIND_UNKNOWN: the LDAP class type is not known
* *
* Defines the LDAP class type * Defines the LDAP class type
*/ */
typedef enum { typedef enum {
skipping to change at line 218 skipping to change at line 230
gchar **names; gchar **names;
gchar *description; gchar *description;
GdaLdapClassKind kind; GdaLdapClassKind kind;
gboolean obsolete; gboolean obsolete;
guint nb_req_attributes; guint nb_req_attributes;
gchar **req_attributes; gchar **req_attributes;
guint nb_opt_attributes; guint nb_opt_attributes;
gchar **opt_attributes; gchar **opt_attributes;
GSList *parents; /* list of #LdapClass */ GSList *parents; /* list of #GdaLdapClass */
GSList *children; /* list of #LdapClass */ GSList *children; /* list of #GdaLdapClass */
} GdaLdapClass; } GdaLdapClass;
GdaLdapClass *gda_ldap_get_class_info (GdaLdapConnection *cnc, const gcha r *classname); GdaLdapClass *gda_ldap_get_class_info (GdaLdapConnection *cnc, const gcha r *classname);
const GSList *gda_ldap_get_top_classes (GdaLdapConnection *cnc); const GSList *gda_ldap_get_top_classes (GdaLdapConnection *cnc);
/**
* GdaLdapModificationType:
* @GDA_LDAP_MODIFICATION_INSERT: modification corresponds to a new LDAP en
try
* @GDA_LDAP_MODIFICATION_DELETE: modification corresponds to removing an L
DAP entry
* @GDA_LDAP_MODIFICATION_ATTR_ADD: modification correspond to adding attri
butes to an existing LDAP entry
* @GDA_LDAP_MODIFICATION_ATTR_DEL: modification correspond to removing att
ributes from an existing LDAP entry
* @GDA_LDAP_MODIFICATION_ATTR_REPL: modification correspond to replacing a
ttributes of an existing LDAP entry
* @GDA_LDAP_MODIFICATION_ATTR_DIFF: modification correspond to modifying a
ttributes to an existing LDAP entry
*
* Speficies the type of operation requested when writing to an LDAP direct
ory.
*/
typedef enum {
GDA_LDAP_MODIFICATION_INSERT,
GDA_LDAP_MODIFICATION_DELETE,
GDA_LDAP_MODIFICATION_ATTR_ADD,
GDA_LDAP_MODIFICATION_ATTR_DEL,
GDA_LDAP_MODIFICATION_ATTR_REPL,
GDA_LDAP_MODIFICATION_ATTR_DIFF
} GdaLdapModificationType;
gboolean gda_ldap_add_entry (GdaLdapConnection *cnc, GdaLdapEntry
*entry, GError **error);
gboolean gda_ldap_remove_entry (GdaLdapConnection *cnc, const gchar
*dn, GError **error);
gboolean gda_ldap_rename_entry (GdaLdapConnection *cnc, const gchar
*current_dn, const gchar *new_dn, GError **error);
gboolean gda_ldap_modify_entry (GdaLdapConnection *cnc, GdaLdapModif
icationType modtype,
GdaLdapEntry *entry, GdaLdapEntry *re
f_entry, GError **error);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 5 change blocks. 
2 lines changed or deleted 55 lines changed or added


 gda-meta-column-types.h   gda-meta-column-types.h 
/* /*
* Copyright (C) 2009 Vivien Malerba <malerba@gnome-db.org> * File generated by the tools/information-schema-types program from the
* * libgda/information_schema.xml file,
* This library is free software; you can redistribute it and/or * This file contains declaration of the expected data types when
* modify it under the terms of the GNU Lesser General Public * extracting meta data, it should be updated when the libgda/information_s
* License as published by the Free Software Foundation; either chema.xml file changes
* version 2 of the License, or (at your option) any later version. * DO NOT MODIFY
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/ */
/* /*
* TABLE: _attributes * TABLE: _attributes
* *
* Table to store (key,value) pairs (keys starting with '_' are reserved) * Table to store (key,value) pairs (keys starting with '_' are reserved)
*/ */
static GType _col_types_attributes[] = { static GType _col_types_attributes[] = {
G_TYPE_STRING /* column: att_name */ G_TYPE_STRING /* column: att_name */
, G_TYPE_STRING /* column: att_value */ , G_TYPE_STRING /* column: att_value */
skipping to change at line 51 skipping to change at line 40
/* /*
* TABLE: _schemata * TABLE: _schemata
* *
* List of schemas * List of schemas
*/ */
static GType _col_types_schemata[] = { static GType _col_types_schemata[] = {
G_TYPE_STRING /* column: catalog_name */ G_TYPE_STRING /* column: catalog_name */
, G_TYPE_STRING /* column: schema_name */ , G_TYPE_STRING /* column: schema_name */
, G_TYPE_STRING /* column: schema_owner */ , G_TYPE_STRING /* column: schema_owner */
, G_TYPE_BOOLEAN /* column: schema_internal */ , G_TYPE_BOOLEAN /* column: schema_internal */
, G_TYPE_BOOLEAN /* column: schema_default */
, G_TYPE_NONE /* end of array marker */ , G_TYPE_NONE /* end of array marker */
}; };
/* /*
* TABLE: _builtin_data_types * TABLE: _builtin_data_types
* *
* List of built-in data types such as varchar, int, ... * List of built-in data types such as varchar, int, ...
*/ */
static GType _col_types_builtin_data_types[] = { static GType _col_types_builtin_data_types[] = {
G_TYPE_STRING /* column: short_type_name */ G_TYPE_STRING /* column: short_type_name */
 End of changes. 2 change blocks. 
16 lines changed or deleted 7 lines changed or added


 gda-meta-store.h   gda-meta-store.h 
skipping to change at line 64 skipping to change at line 64
/* /*
* tracking changes in the meta database * tracking changes in the meta database
*/ */
typedef enum { typedef enum {
GDA_META_STORE_ADD, GDA_META_STORE_ADD,
GDA_META_STORE_REMOVE, GDA_META_STORE_REMOVE,
GDA_META_STORE_MODIFY GDA_META_STORE_MODIFY
} GdaMetaStoreChangeType; } GdaMetaStoreChangeType;
/**
* GdaMetaStoreChange:
* @c_type:
* @table_name:
* @keys: (element-type utf8 GLib.Value):
*/
typedef struct { typedef struct {
/* change general information */ /* change general information */
GdaMetaStoreChangeType c_type; GdaMetaStoreChangeType c_type;
gchar *table_name; gchar *table_name;
GHashTable *keys; /* key = ('+' or '-') and a column pos ition in @table (string) starting at 0, GHashTable *keys; /* key = ('+' or '-') and a column pos ition in @table (string) starting at 0,
* value = a GValue pointer */ * value = a GValue pointer */
} GdaMetaStoreChange; } GdaMetaStoreChange;
/* Pointer type for GdaMetaContext */
#define GDA_TYPE_META_CONTEXT (gda_meta_context_get_type())
/** /**
* GdaMetaContext: * GdaMetaContext:
* @table_name: the name of the table <emphasis>in the GdaMetaStore's inter nal database</emphasis> * @table_name: the name of the table <emphasis>in the GdaMetaStore's inter nal database</emphasis>
* @size: the size of the @column_names and @column_values arrays * @size: the size of the @column_names and @column_values arrays
* @column_names: an array of column names (columns of the @table_name tabl * @column_names: (array length=size): an array of column names (columns of
e) the @table_name table)
* @column_values: an array of values, one for each column named in @column * @column_values: (array length=size): an array of values, one for each co
_names lumn named in @column_names
* @columns: (element-type utf8 GLib.Value): A #GHashTable storing columns'
name as key and #GValue as column's
* value.
* *
* The <structname>GdaMetaContext</structname> represents a meta data modif ication * The <structname>GdaMetaContext</structname> represents a meta data modif ication
* context: the <emphasis>how</emphasis> when used with gda_meta_store_modi fy_with_context(), * context: the <emphasis>how</emphasis> when used with gda_meta_store_modi fy_with_context(),
* and the <emphasis>what</emphasis> when used with gda_connection_update_m eta_store(). * and the <emphasis>what</emphasis> when used with gda_connection_update_m eta_store().
*
* To create a new #GdaMetaContext use #gda_meta_context_new.
*
* To add a new column/value pair use #gda_meta_context_add_column.
*
* To free a #GdaMetaContext, created by #gda_meta_context_new, use #gda_at
tributes_manager_free.
*
* Since 5.2, you must consider this struct as opaque. Any access to its in
ternal must use public API.
* Don't try to use #gda_meta_context_free on a struct that was created man
ually.
*/ */
typedef struct { typedef struct {
gchar *table_name; gchar *table_name;
gint size; gint size;
gchar **column_names; gchar **column_names;
GValue **column_values; GValue **column_values;
GHashTable *columns;/* Added since 5.2 */
} GdaMetaContext; } GdaMetaContext;
/* struct for the object's data */ /* struct for the object's data */
struct _GdaMetaStore struct _GdaMetaStore
{ {
GObject object; GObject object;
GdaMetaStorePrivate *priv; GdaMetaStorePrivate *priv;
}; };
/* struct for the object's class */ /* struct for the object's class */
skipping to change at line 187 skipping to change at line 208
guint nb_cols, guint nb_cols,
gchar **colnames, gchar **ref_colnames, gchar **colnames, gchar **ref_colnames,
GError **error); GError **error);
gboolean gda_meta_store_undeclare_foreign_key (GdaMetaStore *st ore, GdaMetaStruct *mstruct, gboolean gda_meta_store_undeclare_foreign_key (GdaMetaStore *st ore, GdaMetaStruct *mstruct,
const gchar *fk_n ame, const gchar *fk_n ame,
const gchar *cata log, const gchar *schema, const gchar *table, const gchar *cata log, const gchar *schema, const gchar *table,
const gchar *ref_ catalog, const gchar *ref_schema, const gchar *ref_table, const gchar *ref_ catalog, const gchar *ref_schema, const gchar *ref_table,
GError **error); GError **error);
GType gda_meta_context_get_type (void) G_GNUC_CON
ST;
GdaMetaContext* gda_meta_context_new ();
void gda_meta_context_set_table (GdaMetaContext *
ctx, const gchar *table);
const gchar* gda_meta_context_get_table (GdaMetaContext *
ctx);
void gda_meta_context_set_column (GdaMetaContext *
ctx, const gchar* column,
const GValue* val
ue, GdaConnection *cnc);
void gda_meta_context_set_columns (GdaMetaContext *
ctx, GHashTable *columns,
GdaConnection *cn
c);
void gda_meta_context_free (GdaMetaContext *
ctx);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 6 change blocks. 
4 lines changed or deleted 47 lines changed or added


 gda-pstmt.h   gda-pstmt.h 
skipping to change at line 41 skipping to change at line 41
#define GDA_IS_PSTMT(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE _PSTMT)) #define GDA_IS_PSTMT(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE _PSTMT))
#define GDA_IS_PSTMT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYP E_PSTMT)) #define GDA_IS_PSTMT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYP E_PSTMT))
typedef struct _GdaPStmt GdaPStmt; typedef struct _GdaPStmt GdaPStmt;
typedef struct _GdaPStmtPrivate GdaPStmtPrivate; typedef struct _GdaPStmtPrivate GdaPStmtPrivate;
typedef struct _GdaPStmtClass GdaPStmtClass; typedef struct _GdaPStmtClass GdaPStmtClass;
/** /**
* GdaPStmt: * GdaPStmt:
* @sql: actual SQL code used for this prepared statement, mem freed by Gda PStmt * @sql: actual SQL code used for this prepared statement, mem freed by Gda PStmt
* @param_ids: (element-type string): list of parameters' IDs (as gchar *), mem freed by GdaPStmt * @param_ids: (element-type utf8): list of parameters' IDs (as gchar *), m em freed by GdaPStmt
* @ncols: number of types in array * @ncols: number of types in array
* @types: (array length=ncols) (element-type GLib.Type): array of ncols ty pes * @types: (array length=ncols) (element-type GLib.Type): array of ncols ty pes
* @tmpl_columns: (element-type Gda.Colum): list of #GdaColumn objects whic h data models created from this prep. statement can copy * @tmpl_columns: (element-type Gda.Colum): list of #GdaColumn objects whic h data models created from this prep. statement can copy
* *
*/ */
struct _GdaPStmt { struct _GdaPStmt {
GObject object; GObject object;
GdaPStmtPrivate *priv; GdaPStmtPrivate *priv;
gchar *sql; /* actual SQL code used for this prepared stateme nt, mem freed by GdaPStmt */ gchar *sql; /* actual SQL code used for this prepared stateme nt, mem freed by GdaPStmt */
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 gda-quark-list.h   gda-quark-list.h 
skipping to change at line 43 skipping to change at line 43
#define GDA_TYPE_QUARK_LIST (gda_quark_list_get_type()) #define GDA_TYPE_QUARK_LIST (gda_quark_list_get_type())
/** /**
* SECTION:gda-quark-list * SECTION:gda-quark-list
* @short_description: Manages lists of KEY=VALUE pairs * @short_description: Manages lists of KEY=VALUE pairs
* @title: Quark list * @title: Quark list
* @stability: Stable * @stability: Stable
* @see_also: * @see_also:
* *
* This object is used mainly by database providers' implementations to par * This object is used to store KEY=VALUE pairs. It is mainly used internal
se connection ly by Libgda to store connection
* strings into lists of KEY=VALUE pairs. * parameters.
*
* Authentification values are kept in a mangled form in memory, and unmang
led when
* they are requested using gda_quark_list_find(), and when you don't need
them anymore,
* call gda_quark_list_protect_values() to remove the unmangled version.
*/ */
GType gda_quark_list_get_type (void) G_GNUC_CONST; GType gda_quark_list_get_type (void) G_GNUC_CONST;
GdaQuarkList *gda_quark_list_new (void); GdaQuarkList *gda_quark_list_new (void);
GdaQuarkList *gda_quark_list_new_from_string (const gchar *string); GdaQuarkList *gda_quark_list_new_from_string (const gchar *string);
GdaQuarkList *gda_quark_list_copy (GdaQuarkList *qlist); GdaQuarkList *gda_quark_list_copy (GdaQuarkList *qlist);
void gda_quark_list_free (GdaQuarkList *qlist); void gda_quark_list_free (GdaQuarkList *qlist);
void gda_quark_list_add_from_string (GdaQuarkList *qlist, void gda_quark_list_add_from_string (GdaQuarkList *qlist,
const gchar *string, const gchar *string,
gboolean cleanup); gboolean cleanup);
const gchar *gda_quark_list_find (GdaQuarkList *qlist, const gc har *name); const gchar *gda_quark_list_find (GdaQuarkList *qlist, const gc har *name);
void gda_quark_list_protect_values (GdaQuarkList *qlist);
void gda_quark_list_remove (GdaQuarkList *qlist, const gc har *name); void gda_quark_list_remove (GdaQuarkList *qlist, const gc har *name);
void gda_quark_list_clear (GdaQuarkList *qlist); void gda_quark_list_clear (GdaQuarkList *qlist);
void gda_quark_list_foreach (GdaQuarkList *qlist, GHFunc f unc, gpointer user_data); void gda_quark_list_foreach (GdaQuarkList *qlist, GHFunc f unc, gpointer user_data);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 2 change blocks. 
3 lines changed or deleted 11 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/