tp_handle_is_valid ()

gboolean
tp_handle_is_valid (TpHandleRepoIface *self,
                    TpHandle handle,
                    GError **error);

tp_handles_are_valid ()

gboolean
tp_handles_are_valid (TpHandleRepoIface *self,
                      const GArray *handles,
                      gboolean allow_zero,
                      GError **error);

tp_handles_supported_and_valid ()

gboolean
tp_handles_supported_and_valid (TpHandleRepoIface *repos[TP_NUM_ENTITY_TYPES],
                                TpEntityType entity_type,
                                const GArray *handles,
                                gboolean allow_zero,
                                GError **error);

Return TRUE if the given entity type is supported (i.e. repos[entity_type] is not NULL) and the given handles are all valid in that repository. If not, set error and return FALSE.

tp_handle_inspect ()

const char *
tp_handle_inspect (TpHandleRepoIface *self,
                   TpHandle handle);

tp_handle_ensure ()

TpHandle
tp_handle_ensure (TpHandleRepoIface *self,
                  const gchar *id,
                  gpointer context,
                  GError **error);

Return a handle for the given string, creating one if necessary. The string is normalized, if possible.

tp_handle_lookup ()

TpHandle
tp_handle_lookup (TpHandleRepoIface *self,
                  const gchar *id,
                  gpointer context,
                  GError **error);

Return the handle for the given string. The string is normalized if possible. If no handle already exists for the string, none is created.

tp_handle_ensure_async ()

void
tp_handle_ensure_async (TpHandleRepoIface *self,
                        TpBaseConnection *connection,
                        const gchar *id,
                        gpointer context,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

Asyncronously normalize an identifier and create an handle for it. This could involve a server round-trip. This should be used instead of tp_handle_ensure() for user provided contact identifiers, but it is not necessary for identifiers from the server.

Since 0.19.2

tp_handle_ensure_finish ()

TpHandle
tp_handle_ensure_finish (TpHandleRepoIface *self,
                         GAsyncResult *result,
                         GError **error);

Finishes tp_handle_ensure_async()

Since 0.19.2

TP_TYPE_HANDLE_SET

#define TP_TYPE_HANDLE_SET (tp_handle_set_get_type ())

The boxed type of a TpHandleSet.

Since 0.11.6

TpHandleSetMemberFunc ()

void
(*TpHandleSetMemberFunc) (TpHandleSet *set,
                          TpHandle handle,
                          gpointer userdata);

Signature of the callback used to iterate over the handle set in tp_handle_set_foreach().

tp_handle_set_new ()

TpHandleSet *
tp_handle_set_new (TpHandleRepoIface *repo);

Creates a new TpHandleSet

tp_handle_set_new_containing ()

TpHandleSet *
tp_handle_set_new_containing (TpHandleRepoIface *repo,
                              TpHandle handle);

Creates a new TpHandleSet from a specified handle repository and single handle.

Since 0.13.0

tp_handle_set_new_from_array ()

TpHandleSet *
tp_handle_set_new_from_array (TpHandleRepoIface *repo,
                              const GArray *array);

Creates a new TpHandleSet

Since 0.11.7

tp_handle_set_new_from_intset ()

TpHandleSet *
tp_handle_set_new_from_intset (TpHandleRepoIface *repo,
                               const TpIntset *intset);

Creates a new TpHandleSet from a specified handle repository and set of handles.

Since 0.13.0

tp_handle_set_copy ()

TpHandleSet *
tp_handle_set_copy (const TpHandleSet *other);

Creates a new TpHandleSet with the same contents as other .

Since 0.11.6

tp_handle_set_clear ()

void
tp_handle_set_clear (TpHandleSet *set);

Remove every handle from set , releasing the references it holds.

Since 0.11.6

tp_handle_set_destroy ()

void
tp_handle_set_destroy (TpHandleSet *set);

Delete a TpHandleSet and unreference any handles that it holds

tp_handle_set_peek ()

TpIntset *
tp_handle_set_peek (TpHandleSet *set);

tp_handle_set_add ()

void
tp_handle_set_add (TpHandleSet *set,
                   TpHandle handle);

Add a handle to a TpHandleSet, and reference it in the attached TpHandleRepoIface

tp_handle_set_remove ()

gboolean
tp_handle_set_remove (TpHandleSet *set,
                      TpHandle handle);

Remove a handle from a TpHandleSet, and unreference it in the attached TpHandleRepoIface

tp_handle_set_is_member ()

gboolean
tp_handle_set_is_member (const TpHandleSet *set,
                         TpHandle handle);

Check if the handle is in this set

tp_handle_set_foreach ()

void
tp_handle_set_foreach (TpHandleSet *set,
                       TpHandleSetMemberFunc func,
                       gpointer user_data);

Call func (set , handle , userdata ) for each handle in set .

tp_handle_set_is_empty ()

gboolean
tp_handle_set_is_empty (const TpHandleSet *set);

Return the same thing as (tp_handle_set_size (set) == 0), but calculated more efficiently.

Since 0.11.6

tp_handle_set_size ()

int
tp_handle_set_size (const TpHandleSet *set);

tp_handle_set_to_array ()

GArray *
tp_handle_set_to_array (const TpHandleSet *set);

tp_handle_set_to_identifier_map ()

GVariant *
tp_handle_set_to_identifier_map (TpHandleSet *self);

Returns a dictionary mapping each handle in self to the corresponding identifier, as if retrieved by calling tp_handle_inspect() on each handle.

tp_handle_set_update ()

TpIntset *
tp_handle_set_update (TpHandleSet *set,
                      const TpIntset *add);

Add a set of handles to a handle set, referencing those which are not already members. The TpIntset returned must be freed with tp_intset_destroy.

tp_handle_set_difference_update ()

TpIntset *
tp_handle_set_difference_update (TpHandleSet *set,
                                 const TpIntset *remove);

Remove a set of handles from a handle set, dereferencing those which are members. The TpIntset returned must be freed with tp_intset_destroy.

If you want to be able to inspect the handles in the set returned, you must ensure that this function does not cause their refcount to drop to zero, for instance by temporarily taking a reference to all the handles in remove , calling this function, doing something with the result and discarding the temporary references.

tp_handle_set_dump ()

gchar *
tp_handle_set_dump (const TpHandleSet *self);

Format a TpHandleSet for debug output.

TpHandleRepoIface

typedef struct _TpHandleRepoIface TpHandleRepoIface;

Dummy typedef representing any implementation of this interface.

TpHandleRepoIfaceClass

typedef struct _TpHandleRepoIfaceClass TpHandleRepoIfaceClass;

The class of a handle repository interface. The structure layout is only available within telepathy-glib, for the handle repository implementations' benefit.

TpHandleSet

typedef struct _TpHandleSet TpHandleSet;

A set of handles. This is similar to a TpIntset (and implemented using one), but adding a handle to the set also references it.

The “entity-type” property

  “entity-type”              guint

The TpEntityType held in this handle repository.

Flags: Read / Write / Construct Only

Default value: 0