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.

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

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 .

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 .

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 .

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 method 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}").

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.

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.

DBusGTypeSpecializedAppendContext

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

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

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.

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.

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.

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.

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

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