DBusGTypeSpecializedCollectionIterator ()

void                (*DBusGTypeSpecializedCollectionIterator)
                                                        (const GValue *value,
                                                         gpointer user_data);

A library-user-supplied function, called for each element in the collection when dbus_g_type_collection_value_iterate() is called.

DBusGTypeSpecializedMapIterator ()

void                (*DBusGTypeSpecializedMapIterator)  (const GValue *key_val,
                                                         const GValue *value_val,
                                                         gpointer user_data);

A library-user-supplied function, called for each key/value pair in the collection when dbus_g_type_map_value_iterate() is called.

DBusGTypeSpecializedAppendContext

typedef struct {
  /* public */
  GValue *val;
  GType specialization_type;
} DBusGTypeSpecializedAppendContext;

A context for appending. There are more fields, which are private.

DBusGTypeSpecializedConstructor ()

gpointer            (*DBusGTypeSpecializedConstructor)  (GType type);

DBusGTypeSpecializedFreeFunc ()

void                (*DBusGTypeSpecializedFreeFunc)     (GType type,
                                                         gpointer val);

Frees val according to type. This is analogous to GBoxedFreeFunc, but can use information from type (for instance to free the contents of a container before freeing the actual container).

DBusGTypeSpecializedCopyFunc ()

gpointer            (*DBusGTypeSpecializedCopyFunc)     (GType type,
                                                         gpointer src);

Copies src according to type. This is analogous to GBoxedCopyFunc, but can use information from type (for instance to copy each element of a collection).

DBusGTypeSpecializedVtable

typedef struct {
  DBusGTypeSpecializedConstructor    constructor;
  DBusGTypeSpecializedFreeFunc       free_func;
  DBusGTypeSpecializedCopyFunc       copy_func;
  GDestroyNotify                     simple_free_func; /* for type-independent freeing if possible */
} DBusGTypeSpecializedVtable;

A table of methods used to implement specialized container behaviour on user-defined collections, maps and structs. Exactly one of free_func and simple_free_func must be implemented; the other must be NULL. constructor and copy_func must always be implemented.

There are additional members, which are reserved for future expansion and must be NULL.

DBusGTypeSpecializedCollectionFixedAccessorFunc ()

gboolean            (*DBusGTypeSpecializedCollectionFixedAccessorFunc)
                                                        (GType type,
                                                         gpointer instance,
                                                         gpointer *values,
                                                         guint *len);

Implements dbus_g_type_collection_get_fixed() for a GValue with type type, containing instance.

DBusGTypeSpecializedCollectionIteratorFunc ()

void                (*DBusGTypeSpecializedCollectionIteratorFunc)
                                                        (GType type,
                                                         gpointer instance,
                                                         DBusGTypeSpecializedCollectionIterator iterator,
                                                         gpointer user_data);

Implements dbus_g_type_collection_value_iterate() for a GValue with type type, containing instance.

DBusGTypeSpecializedCollectionAppendFunc ()

void                (*DBusGTypeSpecializedCollectionAppendFunc)
                                                        (DBusGTypeSpecializedAppendContext *ctx,
                                                         GValue *val);

Implements dbus_g_type_specialized_collection_append().

This function should use the val and specialization_type members of ctx.

DBusGTypeSpecializedCollectionEndAppendFunc ()

void                (*DBusGTypeSpecializedCollectionEndAppendFunc)
                                                        (DBusGTypeSpecializedAppendContext *ctx);

Implements dbus_g_type_specialized_collection_end_append().

This function should use the val and specialization_type members of ctx.

DBusGTypeSpecializedCollectionVtable

typedef struct {
  DBusGTypeSpecializedVtable                        base_vtable;
  DBusGTypeSpecializedCollectionFixedAccessorFunc   fixed_accessor;
  DBusGTypeSpecializedCollectionIteratorFunc        iterator;
  DBusGTypeSpecializedCollectionAppendFunc          append_func;
  DBusGTypeSpecializedCollectionEndAppendFunc       end_append_func;
} DBusGTypeSpecializedCollectionVtable;

A table of methods used to implement specialized collection behaviour on user-defined types. At least iterator and append_func must be implemented.

DBusGTypeSpecializedMapIteratorFunc ()

void                (*DBusGTypeSpecializedMapIteratorFunc)
                                                        (GType type,
                                                         gpointer instance,
                                                         DBusGTypeSpecializedMapIterator iterator,
                                                         gpointer user_data);

Implements dbus_g_type_map_value_iterate() for a GValue with type type, containing instance.

DBusGTypeSpecializedMapAppendFunc ()

void                (*DBusGTypeSpecializedMapAppendFunc)
                                                        (DBusGTypeSpecializedAppendContext *ctx,
                                                         GValue *key,
                                                         GValue *val);

Implements dbus_g_type_specialized_map_append().

This function should use the val and specialization_type members of ctx, and replace any existing value with key equal to key.

DBusGTypeSpecializedMapVtable

typedef struct {
  DBusGTypeSpecializedVtable                        base_vtable;
  DBusGTypeSpecializedMapIteratorFunc               iterator;
  DBusGTypeSpecializedMapAppendFunc                 append_func;
} DBusGTypeSpecializedMapVtable;

A table of methods used to implement specialized collection behaviour on user-defined types. Both methods must be implemented.

DBusGTypeSpecializedStructGetMember ()

gboolean            (*DBusGTypeSpecializedStructGetMember)
                                                        (GType type,
                                                         gpointer instance,
                                                         guint member,
                                                         GValue *ret_value);

Implements dbus_g_type_struct_get_member() for a GValue with type type, containing instance.

DBusGTypeSpecializedStructSetMember ()

gboolean            (*DBusGTypeSpecializedStructSetMember)
                                                        (GType type,
                                                         gpointer instance,
                                                         guint member,
                                                         const GValue *new_value);

Implements dbus_g_type_struct_set_member() for a GValue with type type, containing instance.

DBusGTypeSpecializedStructVtable

typedef struct {
  DBusGTypeSpecializedVtable                        base_vtable;
  DBusGTypeSpecializedStructGetMember               get_member;
  DBusGTypeSpecializedStructSetMember               set_member;
} DBusGTypeSpecializedStructVtable;

A table of methods used to implement specialized collection behaviour on user-defined types. Both methods must be implemented.

dbus_g_type_get_collection ()

GType               dbus_g_type_get_collection          (const char *container,
                                                         GType specialization);

Gets a GType for a particular collection instance, creating the type if not already created.

dbus_g_type_get_map ()

GType               dbus_g_type_get_map                 (const char *container,
                                                         GType key_specialization,
                                                         GType value_specialization);

Gets a GType for a particular map instance, creating the type if not already created.

dbus_g_type_get_structv ()

GType               dbus_g_type_get_structv             (const char *container,
                                                         guint num_members,
                                                         GType *types);

Gets a GType for a particular struct instance, creating the type if not already created.

dbus_g_type_get_struct ()

GType               dbus_g_type_get_struct              (const char *container,
                                                         GType first_type,
                                                         ...);

Varags methsod to get a GType for a particular struct instance, creating the type if not already created.

dbus_g_type_is_collection ()

gboolean            dbus_g_type_is_collection           (GType gtype);

Tests if a given GType is a collection.

dbus_g_type_is_map ()

gboolean            dbus_g_type_is_map                  (GType gtype);

Tests if a given GType is a map, i.e. it was created with dbus_g_type_get_map().

dbus_g_type_is_struct ()

gboolean            dbus_g_type_is_struct               (GType gtype);

Tests if a given GType is a struct, i.e. it was created with dbus_g_type_get_struct()

dbus_g_type_get_collection_specialization ()

GType               dbus_g_type_get_collection_specialization
                                                        (GType gtype);

Return the type of each element in collections of type gtype. It is an error to call this function on a non-collection type.

dbus_g_type_get_map_key_specialization ()

GType               dbus_g_type_get_map_key_specialization
                                                        (GType gtype);

Return the type of the keys in maps of type gtype. It is an error to call this function on a non-map type.

dbus_g_type_get_map_value_specialization ()

GType               dbus_g_type_get_map_value_specialization
                                                        (GType gtype);

Return the type of the values in maps of type gtype. It is an error to call this function on a non-map type.

dbus_g_type_get_struct_member_type ()

GType               dbus_g_type_get_struct_member_type  (GType gtype,
                                                         guint member);

Get the type of a member of a specialized struct. It is an error to call this function on a non-struct type.

dbus_g_type_get_struct_size ()

guint               dbus_g_type_get_struct_size         (GType gtype);

Get the number of members in a specialized struct. It is an error to call this function on a non-struct type.

dbus_g_type_specialized_construct ()

gpointer            dbus_g_type_specialized_construct   (GType gtype);

Create an instance of a given specialized type. The structure created and returned will depend on the container type of the GType. E.g. If the given type was created by dbus_g_type_get_collection("GArray", G_TYPE_INT), then this will return a GArray with element_size of sizeof(int)

dbus_g_type_specialized_init_append ()

void                dbus_g_type_specialized_init_append (GValue *value,
                                                         DBusGTypeSpecializedAppendContext *ctx);

Create a new context for adding elements to a collection or key/value pairs to a map. You generally don't need or want to use this..

dbus_g_type_specialized_collection_append ()

void                dbus_g_type_specialized_collection_append
                                                        (DBusGTypeSpecializedAppendContext *ctx,
                                                         GValue *elt);

Appends a given element to the end of a collection.

dbus_g_type_specialized_collection_end_append ()

void                dbus_g_type_specialized_collection_end_append
                                                        (DBusGTypeSpecializedAppendContext *ctx);

Finish appending elements to a given collection

dbus_g_type_specialized_map_append ()

void                dbus_g_type_specialized_map_append  (DBusGTypeSpecializedAppendContext *ctx,
                                                         GValue *key,
                                                         GValue *val);

Inserts the given key/value pair into the map instance.

dbus_g_type_collection_get_fixed ()

gboolean            dbus_g_type_collection_get_fixed    (GValue *value,
                                                         gpointer *data_ret,
                                                         guint *len_ret);

Calling this function is likely to be a bad idea. Consider using dbus_g_type_collection_value_iterate() instead.

On success, data_ret is a pointer to the underlying data in a collection of fixed-length fundamental types. Knowledge of the underlying data model of the collection is needed in order to use data_ret correctly.

It is an error to call this function on a specialized type that is not a collection, or on a collection that does not have a fixed_accessor in its DBusGTypeSpecializedCollectionVtable.

Specialized GArrays are the only types provided by dbus-glib that can be used with this function; user-defined types might also work.

dbus_g_type_collection_value_iterate ()

void                dbus_g_type_collection_value_iterate
                                                        (const GValue *value,
                                                         DBusGTypeSpecializedCollectionIterator iterator,
                                                         gpointer user_data);

Calls the given function for each element of the collection. The function is passed a GValue containing the element and the given user_data parameter. The collection may not be modified while iterating over it.

dbus_g_type_map_value_iterate ()

void                dbus_g_type_map_value_iterate       (const GValue *value,
                                                         DBusGTypeSpecializedMapIterator iterator,
                                                         gpointer user_data);

Calls the given function for each key/value pair of the map. The function is passed two GValues containing the key/value pair and the given user_data parameter. The map may not be modified while iterating over it.

dbus_g_type_struct_get_member ()

gboolean            dbus_g_type_struct_get_member       (const GValue *value,
                                                         guint member,
                                                         GValue *dest);

Fetches a given member of a given struct instance. dest must be initialised was the correct type for that member, e.g. as returned by dbus_g_type_get_struct_member_type

dbus_g_type_struct_set_member ()

gboolean            dbus_g_type_struct_set_member       (GValue *value,
                                                         guint member,
                                                         const GValue *src);

Sets a given member of a struct to a new value. The type of src must match the existing type of member member of the struct.

dbus_g_type_struct_get ()

gboolean            dbus_g_type_struct_get              (const GValue *value,
                                                         guint member,
                                                         ...);

Collects the selected values of this struct into the return locations provided.

dbus_g_type_struct_set ()

gboolean            dbus_g_type_struct_set              (GValue *value,
                                                         guint member,
                                                         ...);

Sets the selected members of the struct in value.

dbus_g_type_specialized_init ()

void                dbus_g_type_specialized_init        (void);

Initialize dbus-glib specialized GTypes.

In older versions of dbus-glib, it was necessary to do this before instantiating or registering any specialized type. It is now done automatically whenever necessary.

dbus_g_type_register_collection ()

void                dbus_g_type_register_collection     (const char *name,
                                                         const DBusGTypeSpecializedCollectionVtable *vtable,
                                                         guint flags);

Defines a new collection container.

dbus_g_type_register_map ()

void                dbus_g_type_register_map            (const char *name,
                                                         const DBusGTypeSpecializedMapVtable *vtable,
                                                         guint flags);

Defines a new map container.

dbus_g_type_map_peek_vtable ()

const DBusGTypeSpecializedMapVtable * dbus_g_type_map_peek_vtable
                                                        (GType map_type);

Peek the vtable for a given map specialization

dbus_g_type_collection_peek_vtable ()

const DBusGTypeSpecializedCollectionVtable * dbus_g_type_collection_peek_vtable
                                                        (GType collection_type);

Peek the vtable for a given collection specialization

dbus_g_type_struct_peek_vtable ()

const DBusGTypeSpecializedStructVtable * dbus_g_type_struct_peek_vtable
                                                        (GType struct_type);

Peek the vtable for a given struct specialization

dbus_g_type_register_struct ()

void                dbus_g_type_register_struct         (const char *name,
                                                         const DBusGTypeSpecializedStructVtable *vtable,
                                                         guint flags);

Defines a new struct container.

dbus_g_value_build_g_variant ()

GVariant *          dbus_g_value_build_g_variant        (const GValue *value);

Recurses value and converts its contents to a GVariant.

The value must either be a simple value (integer, string, boolean, object path etc.) or a specialized container registered with dbus_g_type_get_collection(), dbus_g_type_get_map() or dbus_g_type_get_struct(). Providing any other type is a programming error (including as a child type).

dbus_g_value_parse_g_variant ()

void                dbus_g_value_parse_g_variant        (GVariant *variant,
                                                         GValue *value);

Deserialize variant and put an equivalent dbus-glib data structure in value.

It is an error if variant contains any GVariant extensions not supported by dbus-glib, including handles (file descriptor passing) and 'maybe' types.

DBUS_TYPE_G_BOOLEAN_ARRAY

#define DBUS_TYPE_G_BOOLEAN_ARRAY  (dbus_g_type_get_collection ("GArray", G_TYPE_BOOLEAN))

Expands to a function call returning the GType of a GArray of gboolean (corresponding to the D-Bus signature "ab").

DBUS_TYPE_G_UCHAR_ARRAY

#define DBUS_TYPE_G_UCHAR_ARRAY    (dbus_g_type_get_collection ("GArray", G_TYPE_UCHAR))

Expands to a function call returning the GType of a GArray of guchar (corresponding to the D-Bus signature "ay").

Note that this is not the same thing as a GByteArray! dbus-glib does not know about the GByteArray type.

DBUS_TYPE_G_UINT_ARRAY

#define DBUS_TYPE_G_UINT_ARRAY     (dbus_g_type_get_collection ("GArray", G_TYPE_UINT))

Expands to a function call returning the GType of a GArray of guint (corresponding to the D-Bus signature "au").

DBUS_TYPE_G_INT_ARRAY

#define DBUS_TYPE_G_INT_ARRAY      (dbus_g_type_get_collection ("GArray", G_TYPE_INT))

Expands to a function call returning the GType of a GArray of gint (corresponding to the D-Bus signature "ai").

DBUS_TYPE_G_UINT64_ARRAY

#define DBUS_TYPE_G_UINT64_ARRAY   (dbus_g_type_get_collection ("GArray", G_TYPE_UINT64))

Expands to a function call returning the GType of a GArray of guint64 (corresponding to the D-Bus signature "at").

DBUS_TYPE_G_INT64_ARRAY

#define DBUS_TYPE_G_INT64_ARRAY    (dbus_g_type_get_collection ("GArray", G_TYPE_INT64))

Expands to a function call returning the GType of a GArray of gint64 (corresponding to the D-Bus signature "ax").

DBUS_TYPE_G_OBJECT_ARRAY

#define DBUS_TYPE_G_OBJECT_ARRAY   (dbus_g_type_get_collection ("GPtrArray", G_TYPE_OBJECT))

Expands to a function call returning the GType of a GPtrArray of GObject.

Use this type with caution: it can sometimes be used as a representation of arrays whose D-Bus signature is "ao" (transferred as an array of object paths), but the conventional type for such arrays is (dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH)).

DBUS_TYPE_G_STRING_STRING_HASHTABLE

#define DBUS_TYPE_G_STRING_STRING_HASHTABLE (dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING))

Expands to a function call returning the GType of a GHashTable where the keys are strings and the values are also strings (corresponding to the D-Bus signature "a{ss}").

DBusGSignature

typedef gchar DBusGSignature;

A typedef for a string used to represent D-Bus signatures. Its GType is DBUS_TYPE_G_SIGNATURE, derived from G_TYPE_BOXED.

Prior to version 0.FIXME this was used as the type name of DBUS_TYPE_G_SIGNATURE, but did not actually exist as a typedef.

Since 0.FIXME

DBUS_TYPE_G_SIGNATURE

#define DBUS_TYPE_G_SIGNATURE (dbus_g_signature_get_g_type ())

The GType of a DBusGSignature, which is a boxed type containing a D-Bus signature as a zero-terminated string. Signatures can be copied with g_strdup() and freed with g_free(), just like G_TYPE_STRING, but have a distinct boxed type to allow them to be distinguished when stored in a GValue.

DBusGObjectPath

typedef gchar DBusGObjectPath;

A typedef for a string used to represent D-Bus object paths. Its GType is DBUS_TYPE_G_OBJECT_PATH, derived from G_TYPE_BOXED.

Prior to version 0.FIXME this was used as the type name of DBUS_TYPE_G_OBJECT_PATH, but did not actually exist as a typedef.

Since 0.FIXME

DBUS_TYPE_G_OBJECT_PATH

#define DBUS_TYPE_G_OBJECT_PATH (dbus_g_object_path_get_g_type ())

The GType of a DBusGObjectPath, which is a boxed type containing a D-Bus object path as a zero-terminated string. Object paths can be copied with g_strdup() and freed with g_free(), just like G_TYPE_STRING, but have a distinct boxed type to allow them to be distinguished when stored in a GValue.