GETTEXT_PACKAGE

#define GETTEXT_PACKAGE "midgard"

MidgardConnectionClass

typedef struct MidgardConnectionClass MidgardConnectionClass;

MidgardConnectionPrivate

typedef struct _MidgardConnectionPrivate MidgardConnectionPrivate;

MidgardConnectionCache

typedef struct _MidgardConnectionCache MidgardConnectionCache;

midgard_connection

typedef struct _midgardConnection midgard_connection;

midgard_connection_new ()

MidgardConnection * midgard_connection_new              (void);

Initializes new instance of MidgardConnection object type.

MidgardConnectionClass has no properties registered as class members. Every internal data of MidgardConnection object is accessible with API functions, and is not settable or gettable as property's value. Particular methods should be implemented for language bindings.

MidgardConnection objects holds runtime ( or request ) non persistent data like language, sitegroup, authentication type.

Persistent data like database name, blobs directory are associated with MidgardConfig object.

midgard_connection_open ()

gboolean            midgard_connection_open             (MidgardConnection *self,
                                                         const gchar *name,
                                                         GError **error);

Opens a connection to the database, which is defined in named configuration. The configuration file is read from the system configuration directory and is used as the configuration for the created connection. For example: `/etc` directory is taken into account if library is compiled with `/usr' prefix, `/usr/local/etc` if compiled with `/usr/local` prefix, etc.

Consider using midgard_connection_open_config(), if you need to open connection to database which is configured in user's home directory.

If the named database configuration can not be read or the connection fails, then FALSE is returned and an error message is written to the global midgard error state.

It also initializes MidgardSchema object (which is encapsulated by implementation ) and register all MgdSchema, MgdObjectClass derived classes defined by user. This happens only when basic Midgard classes are not registered in GType system. This is recommended way to initialize MgdSchema types.

midgard_connection_open_config ()

gboolean            midgard_connection_open_config      (MidgardConnection *self,
                                                         MidgardConfig *config);

Opens a MidgardConnection with the given configuration.

Take a look at midgard_connection_open() wrt MidgardSchema.

midgard_connection_close ()

void                midgard_connection_close            (MidgardConnection *self);

Closes database connection.

This function closes database connection , destroys MidgardConnection object and frees its memory. It may be replaced by g_object_unref, with one exception.

When MidgardConnection object is initialized with midgard_connection_open function then MidgardConfig object is also destroyed and its memory is freed.

Caller is responsible to free MidgardConfig object when is used with MidgardConnection and connection object was initialized with midgard_connection_open_config function.

midgard_connection_set_sitegroup ()

gboolean            midgard_connection_set_sitegroup    (MidgardConnection *self,
                                                         const gchar *name);

Sets sitegroup's value for the given MidgardConnection.

Given sitegroup's name must be the value of exisiting in database sitegroup's record. When there is no sitegroup with such name or sitegroup is private , then connection's sitegroup is unchanged and method return FALSE.

See also: midgard_sitegroup_list if you need to get list of available sitegroup names.

Emits: "sitegroup_changed"

midgard_connection_get_sitegroup ()

const gchar *       midgard_connection_get_sitegroup    (MidgardConnection *self);

Returns name of a sitegroup which is currently used for a connection.

Read more about Midgard sitegroups concept

midgard_connection_set_lang ()

gboolean            midgard_connection_set_lang         (MidgardConnection *self,
                                                         const gchar *language);

Sets the language of the given Midgard connection. The connection language affects all MultiLang database accesses as described in the Midgard MultiLang documentation.

The given language parameter is the two-letter language code stored in the language table in the Midgard database. Special 'lang 0' might be set with empty string given instead of language code.

This method returns FALSE if the given language is not found.

Read more about Multilingual content

See also: midgard_connection_set_default_lang

Emits: "lang-changed"

midgard_connection_set_default_lang ()

gboolean            midgard_connection_set_default_lang (MidgardConnection *self,
                                                         const gchar *language);

Sets default language for the given MidgardConnection.

This function sets both (default and fallback) languages. Application works only in default language context. You should call midgard_connection_set_lang (after setting default language), if fallback language should be different.

midgard_connection_get_lang ()

const gchar *       midgard_connection_get_lang         (MidgardConnection *self);

Returned language string is the two-letter language code. See also: midgard_connection_get_default_lang

midgard_connection_get_default_lang ()

const gchar *       midgard_connection_get_default_lang (MidgardConnection *self);

\return

Returned language string is the two-letter language code.

See also: midgard_connection_get_lang

midgard_connection_set_loglevel ()

gboolean            midgard_connection_set_loglevel     (MidgardConnection *self,
                                                         const gchar *level,
                                                         GLogFunc log_func);

Sets log level of the given MidgardConnection. Overwrites internal MidgardConnection's log level defined in configuration file. By default MidgardConnection holds loglevel which is associated with ( and duplicated from ) MidgardConfig. MidgardConfig object's log level isn't changed by this function

This method is a shortcut which sets correctly loghandler,loglevel and GLib's log function. Default log function will be used if NULL is defined. Core's default function is midgard_error_default_log.

Available levels: error, warn, warning, info, message, debug. warn is default loglevel, SQL queries are logged with debug level. With info level, function names ( and classes' names ) are ( at least should be) logged in language bindings

midgard_connection_get_loglevel ()

guint               midgard_connection_get_loglevel     (MidgardConnection *self);

midgard_connection_set_loghandler ()

void                midgard_connection_set_loghandler   (MidgardConnection *self,
                                                         guint loghandler);

Sets internal loghandler id associated with G_LOG_DOMAIN and loglevel. Caller is responsible to remove loghandler using g_log_remove_handler when new loglevel for G_LOG_DOMAIN is set.

See also: midgard_connection_set_loglevel

midgard_connection_get_loghandler ()

guint               midgard_connection_get_loghandler   (MidgardConnection *self);

midgard_connection_get_sitegroup_from_id ()

const gchar *       midgard_connection_get_sitegroup_from_id
                                                        (MidgardConnection *self,
                                                         guint id);

This method returns name for the sitegroup which is identified by given id. You should use this method only ( and only ) when you need ( for example ) set connection's sitegroup using sitegroup's id set to an object.

This is transition helper method.

midgard_connection_get_sitegroup_id ()

guint               midgard_connection_get_sitegroup_id (MidgardConnection *self);

midgard_connection_get_lang_from_id ()

const gchar *       midgard_connection_get_lang_from_id (MidgardConnection *self,
                                                         guint id);

This is transition helper method.

midgard_connection_get_lang_id ()

guint               midgard_connection_get_lang_id      (MidgardConnection *self,
                                                         const gchar *language);

Returned id is an integer which identifies language for the given MidgardConnection. If language parameter is different than NULL, internal lookup is made to find matching language id.

midgard_connection_get_error ()

gint                midgard_connection_get_error        (MidgardConnection *self);

Error id may be one of set by midgard_error.

midgard_connection_get_error_string ()

const gchar *       midgard_connection_get_error_string (MidgardConnection *self);

Error string may be one set by midgard_error.

midgard_connection_get_user ()

MidgardUser *       midgard_connection_get_user         (MidgardConnection *self);

NULL is explicitly returned if there's no midgard_user logged in for the given MidgardConnection. See also MidgardUser methods if you need midgard_person associated with user.

midgard_connection_set_request_config ()

gboolean            midgard_connection_set_request_config
                                                        (MidgardConnection *self,
                                                         MidgardRequestConfig *rcfg);

Request configuration may be set only once. A warning is thrown if there's already request config associated.

midgard_connection_get_request_config ()

const MidgardRequestConfig * midgard_connection_get_request_config
                                                        (MidgardConnection *self);

Returned pointer is a reference to MidgardRequestConfig and should not be freed. It's implictly freed by language bindings or by connection for which it has been set.

midgard_connection_copy ()

MidgardConnection * midgard_connection_copy             (MidgardConnection *self);

This function duplicates given MidgardConnection. It doesn't make deep copy. All persistant data are kept unchanged, but runtime related members are reset to default state. This function is helpful if application is forking and new processes might have different environment variables, like sitegroup or language.

Call g_object_unref if returned object is no longer needed.

midgard_connection_list_languages ()

const GObject **    midgard_connection_list_languages   (MidgardConnection *self,
                                                         guint *n_objects);

Returns array of all available languages. Returned array is owned by MidgardConnection and shouldn't be freed.

The "auth-changed" signal

void                user_function                      (midgard_connection *midgard_connection,
                                                        gpointer            user_data)               : Run Last / No Recursion / No Hooks

The "error" signal

void                user_function                      (midgard_connection *midgard_connection,
                                                        gpointer            user_data)               : Run Last / No Recursion / No Hooks

The "lang-changed" signal

void                user_function                      (midgard_connection *midgard_connection,
                                                        gpointer            user_data)               : Run Last / No Recursion / No Hooks

The "lost-provider" signal

void                user_function                      (midgard_connection *midgard_connection,
                                                        gpointer            user_data)               : Run Last / No Recursion / No Hooks

The "sitegroup-changed" signal

void                user_function                      (midgard_connection *midgard_connection,
                                                        gpointer            user_data)               : Run Last / No Recursion / No Hooks