Back to index

libunity  5.92.0
Classes | Defines | Typedefs | Functions | Variables
unity-tool-dbus-util.c File Reference
#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <gio/gio.h>
#include <gobject/gvaluecollector.h>

Go to the source code of this file.

Classes

struct  _UnityTesterDBusLensUtil
struct  _UnityTesterDBusLensUtilClass
struct  _UnityTesterDBusLensUtilDBusObjectAddress
struct  _UnityTesterDBusLensUtilPrivate
struct  _unity_tester_dbus_lens_util_findLensesData
struct  _UnityTesterParamSpecDBusLensUtil

Defines

#define UNITY_TESTER_TYPE_DBUS_LENS_UTIL   (unity_tester_dbus_lens_util_get_type ())
#define UNITY_TESTER_DBUS_LENS_UTIL(obj)   (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtil))
#define UNITY_TESTER_DBUS_LENS_UTIL_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtilClass))
#define UNITY_TESTER_IS_DBUS_LENS_UTIL(obj)   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_TESTER_TYPE_DBUS_LENS_UTIL))
#define UNITY_TESTER_IS_DBUS_LENS_UTIL_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_TESTER_TYPE_DBUS_LENS_UTIL))
#define UNITY_TESTER_DBUS_LENS_UTIL_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtilClass))
#define UNITY_TESTER_DBUS_LENS_UTIL_TYPE_DBUS_OBJECT_ADDRESS   (unity_tester_dbus_lens_util_dbus_object_address_get_type ())
#define _g_regex_unref0(var)   ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _g_free0(var)   (var = (g_free (var), NULL))
#define __g_queue_free__unity_tester_dbus_lens_util_dbus_object_address_free0_0(var)   ((var == NULL) ? NULL : (var = (_g_queue_free__unity_tester_dbus_lens_util_dbus_object_address_free0_ (var), NULL)))
#define __g_list_free__unity_tester_dbus_lens_util_dbus_object_address_free0_0(var)   ((var == NULL) ? NULL : (var = (_g_list_free__unity_tester_dbus_lens_util_dbus_object_address_free0_ (var), NULL)))
#define _g_error_free0(var)   ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
#define _g_variant_type_free0(var)   ((var == NULL) ? NULL : (var = (g_variant_type_free (var), NULL)))
#define __g_list_free__g_free0_0(var)   ((var == NULL) ? NULL : (var = (_g_list_free__g_free0_ (var), NULL)))
#define _g_object_unref0(var)   ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_variant_unref0(var)   ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
#define _unity_tester_dbus_lens_util_unref0(var)   ((var == NULL) ? NULL : (var = (unity_tester_dbus_lens_util_unref (var), NULL)))
#define _g_variant_builder_unref0(var)   ((var == NULL) ? NULL : (var = (g_variant_builder_unref (var), NULL)))
#define _unity_tester_dbus_lens_util_dbus_object_address_free0(var)   ((var == NULL) ? NULL : (var = (unity_tester_dbus_lens_util_dbus_object_address_free (var), NULL)))
#define _g_markup_parse_context_free0(var)   ((var == NULL) ? NULL : (var = (g_markup_parse_context_free (var), NULL)))
#define UNITY_TESTER_DBUS_LENS_UTIL_GET_PRIVATE(o)   (G_TYPE_INSTANCE_GET_PRIVATE ((o), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtilPrivate))

Typedefs

typedef struct _UnityTesterDBusLensUtil
typedef struct _UnityTesterDBusLensUtilClass
typedef struct _UnityTesterDBusLensUtilPrivate
typedef struct _UnityTesterDBusLensUtilDBusObjectAddress
typedef struct _unity_tester_dbus_lens_util_findLensesData
typedef struct _UnityTesterParamSpecDBusLensUtil

Functions

gpointer unity_tester_dbus_lens_util_ref (gpointer instance)
void unity_tester_dbus_lens_util_unref (gpointer instance)
GParamSpec * unity_tester_param_spec_dbus_lens_util (const gchar *name, const gchar *nick, const gchar *blurb, GType object_type, GParamFlags flags)
void unity_tester_value_set_dbus_lens_util (GValue *value, gpointer v_object)
void unity_tester_value_take_dbus_lens_util (GValue *value, gpointer v_object)
gpointer unity_tester_value_get_dbus_lens_util (const GValue *value)
GType unity_tester_dbus_lens_util_get_type (void)
static void _unity_tester_dbus_lens_util_dbus_object_address_free0_ (gpointer var)
static void _g_queue_free__unity_tester_dbus_lens_util_dbus_object_address_free0_ (GQueue *self)
static void _g_list_free__unity_tester_dbus_lens_util_dbus_object_address_free0_ (GList *self)
static void unity_tester_dbus_lens_util_start (UnityTesterDBusLensUtil *self, GMarkupParseContext *context, const gchar *name, gchar **attr_names, int attr_names_length1, gchar **attr_values, int attr_values_length1, GError **error)
static void _unity_tester_dbus_lens_util_start_gmarkup_parser_start_element_func (GMarkupParseContext *context, const gchar *element_name, gchar **attribute_names, gchar **attribute_values, gpointer self, GError **error)
UnityTesterDBusLensUtil * unity_tester_dbus_lens_util_new (void)
UnityTesterDBusLensUtil * unity_tester_dbus_lens_util_construct (GType object_type)
static GList * unity_tester_dbus_lens_util_getServices (UnityTesterDBusLensUtil *self, GError **error)
static void _g_free0_ (gpointer var)
 Discover available DBus services.
static void _g_list_free__g_free0_ (GList *self)
static gint _______lambda2_ (UnityTesterDBusLensUtilDBusObjectAddress *a, UnityTesterDBusLensUtilDBusObjectAddress *b)
static gint ________lambda2__gcompare_func (gconstpointer a, gconstpointer b)
static void unity_tester_dbus_lens_util_findLenses_data_free (gpointer _data)
void unity_tester_dbus_lens_util_findLenses (UnityTesterDBusLensUtil *self, GAsyncReadyCallback _callback_, gpointer _user_data_)
GList * unity_tester_dbus_lens_util_findLenses_finish (UnityTesterDBusLensUtil *self, GAsyncResult *_res_, GError **error)
static gboolean unity_tester_dbus_lens_util_findLenses_co (unity_tester_dbus_lens_util_findLensesData *_data_)
static GVariant * _variant_new2 (const gchar *value)
 Find objects implementing com.canonical.Unity.Lens interface.
static gboolean _unity_tester_dbus_lens_util_findLenses_co_gsource_func (gpointer self)
static void unity_tester_dbus_lens_util_finalize (UnityTesterDBusLensUtil *obj)
static gint _vala_array_length (gpointer array)
static gpointer _unity_tester_dbus_lens_util_dbus_object_address_dup0 (gpointer self)
static gpointer _unity_tester_dbus_lens_util_ref0 (gpointer self)
void unity_tester_dbus_lens_util_dbus_object_address_copy (const UnityTesterDBusLensUtilDBusObjectAddress *self, UnityTesterDBusLensUtilDBusObjectAddress *dest)
void unity_tester_dbus_lens_util_dbus_object_address_destroy (UnityTesterDBusLensUtilDBusObjectAddress *self)
UnityTesterDBusLensUtilDBusObjectAddress * unity_tester_dbus_lens_util_dbus_object_address_dup (const UnityTesterDBusLensUtilDBusObjectAddress *self)
void unity_tester_dbus_lens_util_dbus_object_address_free (UnityTesterDBusLensUtilDBusObjectAddress *self)
GType unity_tester_dbus_lens_util_dbus_object_address_get_type (void)
static void unity_tester_value_dbus_lens_util_init (GValue *value)
static void unity_tester_value_dbus_lens_util_free_value (GValue *value)
static void unity_tester_value_dbus_lens_util_copy_value (const GValue *src_value, GValue *dest_value)
static gpointer unity_tester_value_dbus_lens_util_peek_pointer (const GValue *value)
static gchar * unity_tester_value_dbus_lens_util_collect_value (GValue *value, guint n_collect_values, GTypeCValue *collect_values, guint collect_flags)
static gchar * unity_tester_value_dbus_lens_util_lcopy_value (const GValue *value, guint n_collect_values, GTypeCValue *collect_values, guint collect_flags)
static void unity_tester_dbus_lens_util_class_init (UnityTesterDBusLensUtilClass *klass)
static void unity_tester_dbus_lens_util_instance_init (UnityTesterDBusLensUtil *self)

Variables

static gpointer unity_tester_dbus_lens_util_parent_class = NULL
static const GMarkupParser UNITY_TESTER_DBUS_LENS_UTIL_parser = {_unity_tester_dbus_lens_util_start_gmarkup_parser_start_element_func, NULL, NULL, NULL, NULL}

Class Documentation

struct _UnityTesterDBusLensUtil

Definition at line 43 of file unity-tool-dbus-util.c.

Class Members
GTypeInstance parent_instance
UnityTesterDBusLensUtilPrivate * priv
volatile int ref_count
struct _UnityTesterDBusLensUtilDBusObjectAddress

Definition at line 54 of file unity-tool-dbus-util.c.

Class Members
gchar * dbus_name
gchar * dbus_path
struct _UnityTesterDBusLensUtilPrivate

Definition at line 59 of file unity-tool-dbus-util.c.

Class Members
gchar * current_dbus_name
gchar * current_dbus_path
GRegex * lens_dbusname_regex
GList * lenses
GQueue * nodes
struct _unity_tester_dbus_lens_util_findLensesData

Definition at line 67 of file unity-tool-dbus-util.c.

Collaboration diagram for _unity_tester_dbus_lens_util_findLensesData:
Class Members
GSimpleAsyncResult * _async_result
GError * _inner_error_
GAsyncResult * _res_
GObject * _source_object_
int _state_
GRegex * _tmp0_
gboolean _tmp10_
GVariantType * _tmp11_
GVariantType * _tmp12_
GVariantBuilder * _tmp13_
GVariantBuilder * _tmp14_
GVariantBuilder * _tmp15_
const gchar * _tmp16_
GVariant * _tmp17_
GDBusConnection * _tmp18_
GVariantBuilder * _tmp19_
FILE * _tmp1_
GVariant * _tmp20_
GVariant * _tmp21_
const GVariantType * _tmp22_
GVariant * _tmp23_
GVariant * _tmp24_
GVariant * _tmp25_
GVariant * _tmp26_
GVariant * _tmp27_
GVariant * _tmp28_
const gchar * _tmp29_
GList * _tmp2_
gchar * _tmp30_
gchar * _tmp31_
const gchar * _tmp32_
const gchar * _tmp33_
gchar * _tmp34_
gchar * _tmp35_
UnityTesterDBusLensUtilDBusObjectAddress _tmp36_
GQueue * _tmp37_
UnityTesterDBusLensUtilDBusObjectAddress _tmp38_
UnityTesterDBusLensUtilDBusObjectAddress _tmp39_
GDBusConnection * _tmp3_
UnityTesterDBusLensUtilDBusObjectAddress * _tmp40_
GQueue * _tmp41_
guint _tmp42_
GQueue * _tmp43_
gpointer _tmp44_
UnityTesterDBusLensUtilDBusObjectAddress * _tmp45_
UnityTesterDBusLensUtilDBusObjectAddress _tmp46_
UnityTesterDBusLensUtilDBusObjectAddress _tmp47_
UnityTesterDBusLensUtilDBusObjectAddress _tmp48_
const gchar * _tmp49_
GVariantType * _tmp4_
gchar * _tmp50_
UnityTesterDBusLensUtilDBusObjectAddress _tmp51_
const gchar * _tmp52_
gchar * _tmp53_
GDBusConnection * _tmp54_
const gchar * _tmp55_
const gchar * _tmp56_
const GVariantType * _tmp57_
GVariant * _tmp58_
GVariant * _tmp59_
GList * _tmp5_
GVariant * _tmp60_
GVariant * _tmp61_
GVariant * _tmp62_
const gchar * _tmp63_
gchar * _tmp64_
gchar * _tmp65_
GMarkupParseContext * _tmp66_
GMarkupParseContext * _tmp67_
const gchar * _tmp68_
const gchar * _tmp69_
GList * _tmp6_
gint _tmp70_
gint _tmp71_
GList * _tmp72_
gchar * _tmp7_
GRegex * _tmp8_
const gchar * _tmp9_
GError * _vala1_e
GVariant * _vala1_v
GDBusConnection * bus
GMarkupParseContext * context
GError * e
UnityTesterDBusLensUtilDBusObjectAddress node
UnityTesterDBusLensUtilDBusObjectAddress obj
gchar * owner
GList * result
UnityTesterDBusLensUtil * self
gchar * srv
GList * srv_collection
GList * srv_it
GVariant * v
GVariantBuilder * vb
GVariantType * vt
gchar * xmldata
struct _UnityTesterParamSpecDBusLensUtil

Definition at line 165 of file unity-tool-dbus-util.c.

Class Members
GParamSpec parent_instance

Define Documentation

#define __g_list_free__g_free0_0 (   var)    ((var == NULL) ? NULL : (var = (_g_list_free__g_free0_ (var), NULL)))

Definition at line 33 of file unity-tool-dbus-util.c.

Definition at line 30 of file unity-tool-dbus-util.c.

Definition at line 29 of file unity-tool-dbus-util.c.

#define _g_error_free0 (   var)    ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

Definition at line 31 of file unity-tool-dbus-util.c.

#define _g_free0 (   var)    (var = (g_free (var), NULL))

Definition at line 28 of file unity-tool-dbus-util.c.

#define _g_markup_parse_context_free0 (   var)    ((var == NULL) ? NULL : (var = (g_markup_parse_context_free (var), NULL)))

Definition at line 39 of file unity-tool-dbus-util.c.

#define _g_object_unref0 (   var)    ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

Definition at line 34 of file unity-tool-dbus-util.c.

#define _g_regex_unref0 (   var)    ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))

Definition at line 27 of file unity-tool-dbus-util.c.

#define _g_variant_builder_unref0 (   var)    ((var == NULL) ? NULL : (var = (g_variant_builder_unref (var), NULL)))

Definition at line 37 of file unity-tool-dbus-util.c.

#define _g_variant_type_free0 (   var)    ((var == NULL) ? NULL : (var = (g_variant_type_free (var), NULL)))

Definition at line 32 of file unity-tool-dbus-util.c.

#define _g_variant_unref0 (   var)    ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))

Definition at line 35 of file unity-tool-dbus-util.c.

#define _unity_tester_dbus_lens_util_dbus_object_address_free0 (   var)    ((var == NULL) ? NULL : (var = (unity_tester_dbus_lens_util_dbus_object_address_free (var), NULL)))

Definition at line 38 of file unity-tool-dbus-util.c.

#define _unity_tester_dbus_lens_util_unref0 (   var)    ((var == NULL) ? NULL : (var = (unity_tester_dbus_lens_util_unref (var), NULL)))

Definition at line 36 of file unity-tool-dbus-util.c.

#define UNITY_TESTER_DBUS_LENS_UTIL (   obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtil))

Definition at line 15 of file unity-tool-dbus-util.c.

#define UNITY_TESTER_DBUS_LENS_UTIL_CLASS (   klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtilClass))

Definition at line 16 of file unity-tool-dbus-util.c.

#define UNITY_TESTER_DBUS_LENS_UTIL_GET_CLASS (   obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtilClass))

Definition at line 19 of file unity-tool-dbus-util.c.

#define UNITY_TESTER_DBUS_LENS_UTIL_GET_PRIVATE (   o)    (G_TYPE_INSTANCE_GET_PRIVATE ((o), UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtilPrivate))

Definition at line 25 of file unity-tool-dbus-util.c.

#define UNITY_TESTER_IS_DBUS_LENS_UTIL (   obj)    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_TESTER_TYPE_DBUS_LENS_UTIL))

Definition at line 17 of file unity-tool-dbus-util.c.

#define UNITY_TESTER_IS_DBUS_LENS_UTIL_CLASS (   klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_TESTER_TYPE_DBUS_LENS_UTIL))

Definition at line 18 of file unity-tool-dbus-util.c.

Definition at line 14 of file unity-tool-dbus-util.c.


Typedef Documentation

Definition at line 40 of file unity-tool-dbus-util.c.

typedef struct _UnityTesterDBusLensUtil

Definition at line 21 of file unity-tool-dbus-util.c.

Definition at line 22 of file unity-tool-dbus-util.c.

Definition at line 26 of file unity-tool-dbus-util.c.

Definition at line 23 of file unity-tool-dbus-util.c.

Definition at line 41 of file unity-tool-dbus-util.c.


Function Documentation

static gint ________lambda2__gcompare_func ( gconstpointer  a,
gconstpointer  b 
) [static]

Definition at line 419 of file unity-tool-dbus-util.c.

                                                                              {
       gint result;
       result = _______lambda2_ (a, b);
       return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gint _______lambda2_ ( UnityTesterDBusLensUtilDBusObjectAddress *  a,
UnityTesterDBusLensUtilDBusObjectAddress *  b 
) [static]

Definition at line 380 of file unity-tool-dbus-util.c.

                                                                                                                       {
       gint result = 0;
       gint _tmp0_ = 0;
       gboolean _tmp1_ = FALSE;
       UnityTesterDBusLensUtilDBusObjectAddress* _tmp2_;
       const gchar* _tmp3_;
       UnityTesterDBusLensUtilDBusObjectAddress* _tmp4_;
       const gchar* _tmp5_;
       gboolean _tmp10_;
       gint _tmp11_;
       _tmp2_ = a;
       _tmp3_ = (*_tmp2_).dbus_name;
       _tmp4_ = b;
       _tmp5_ = (*_tmp4_).dbus_name;
       if (g_strcmp0 (_tmp3_, _tmp5_) == 0) {
              UnityTesterDBusLensUtilDBusObjectAddress* _tmp6_;
              const gchar* _tmp7_;
              UnityTesterDBusLensUtilDBusObjectAddress* _tmp8_;
              const gchar* _tmp9_;
              _tmp6_ = a;
              _tmp7_ = (*_tmp6_).dbus_path;
              _tmp8_ = b;
              _tmp9_ = (*_tmp8_).dbus_path;
              _tmp1_ = g_strcmp0 (_tmp7_, _tmp9_) == 0;
       } else {
              _tmp1_ = FALSE;
       }
       _tmp10_ = _tmp1_;
       if (_tmp10_) {
              _tmp0_ = 0;
       } else {
              _tmp0_ = 1;
       }
       _tmp11_ = _tmp0_;
       result = _tmp11_;
       return result;
}

Here is the caller graph for this function:

static void _g_free0_ ( gpointer  var) [static]

Discover available DBus services.

Definition at line 277 of file unity-tool-dbus-util.c.

                                     {
       var = (g_free (var), NULL);
}

Here is the caller graph for this function:

static void _g_list_free__g_free0_ ( GList *  self) [static]

Definition at line 282 of file unity-tool-dbus-util.c.

                                                 {
       g_list_foreach (self, (GFunc) _g_free0_, NULL);
       g_list_free (self);
}

Here is the call graph for this function:

Definition at line 222 of file unity-tool-dbus-util.c.

                                                                                               {
       g_list_foreach (self, (GFunc) _unity_tester_dbus_lens_util_dbus_object_address_free0_, NULL);
       g_list_free (self);
}

Here is the call graph for this function:

Definition at line 216 of file unity-tool-dbus-util.c.

                                                                                                 {
       g_queue_foreach (self, (GFunc) _unity_tester_dbus_lens_util_dbus_object_address_free0_, NULL);
       g_queue_free (self);
}

Here is the call graph for this function:

static gpointer _unity_tester_dbus_lens_util_dbus_object_address_dup0 ( gpointer  self) [static]

Definition at line 375 of file unity-tool-dbus-util.c.

                                                                                      {
       return self ? unity_tester_dbus_lens_util_dbus_object_address_dup (self) : NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void _unity_tester_dbus_lens_util_dbus_object_address_free0_ ( gpointer  var) [static]

Definition at line 211 of file unity-tool-dbus-util.c.

                                                                                   {
       (var == NULL) ? NULL : (var = (unity_tester_dbus_lens_util_dbus_object_address_free (var), NULL));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean _unity_tester_dbus_lens_util_findLenses_co_gsource_func ( gpointer  self) [static]

Definition at line 679 of file unity-tool-dbus-util.c.

                                                                                        {
       gboolean result;
       result = unity_tester_dbus_lens_util_findLenses_co (self);
       return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gpointer _unity_tester_dbus_lens_util_ref0 ( gpointer  self) [static]

Definition at line 641 of file unity-tool-dbus-util.c.

                                                                  {
       return self ? unity_tester_dbus_lens_util_ref (self) : NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void _unity_tester_dbus_lens_util_start_gmarkup_parser_start_element_func ( GMarkupParseContext *  context,
const gchar *  element_name,
gchar **  attribute_names,
gchar **  attribute_values,
gpointer  self,
GError **  error 
) [static]

Definition at line 228 of file unity-tool-dbus-util.c.

                                                                                                                                                                                                                             {
       unity_tester_dbus_lens_util_start (self, context, element_name, attribute_names, _vala_array_length (attribute_names), attribute_values, _vala_array_length (attribute_values), error);
}

Here is the call graph for this function:

static gint _vala_array_length ( gpointer  array) [static]

Definition at line 1181 of file unity-tool-dbus-util.c.

                                                {
       int length;
       length = 0;
       if (array) {
              while (((gpointer*) array)[length]) {
                     length++;
              }
       }
       return length;
}

Here is the caller graph for this function:

static GVariant * _variant_new2 ( const gchar *  value) [static]

Find objects implementing com.canonical.Unity.Lens interface.

Definition at line 674 of file unity-tool-dbus-util.c.

                                                    {
       return g_variant_ref_sink (g_variant_new_string (value));
}

Here is the caller graph for this function:

static void unity_tester_dbus_lens_util_class_init ( UnityTesterDBusLensUtilClass *  klass) [static]

Definition at line 1121 of file unity-tool-dbus-util.c.

                                                                                          {
       unity_tester_dbus_lens_util_parent_class = g_type_class_peek_parent (klass);
       UNITY_TESTER_DBUS_LENS_UTIL_CLASS (klass)->finalize = unity_tester_dbus_lens_util_finalize;
       g_type_class_add_private (klass, sizeof (UnityTesterDBusLensUtilPrivate));
}

Here is the call graph for this function:

UnityTesterDBusLensUtil * unity_tester_dbus_lens_util_construct ( GType  object_type)

Definition at line 233 of file unity-tool-dbus-util.c.

                                                                                   {
       UnityTesterDBusLensUtil* self = NULL;
       GError * _inner_error_ = NULL;
       self = (UnityTesterDBusLensUtil*) g_type_create_instance (object_type);
       {
              GRegex* _tmp0_;
              GRegex* _tmp1_;
              _tmp0_ = g_regex_new ("^([a-zA-Z-]+(\\.[a-zA-Z-]+)+)\\.T[\\d]+.[a-zA-Z]+$", 0, 0, &_inner_error_);
              _tmp1_ = _tmp0_;
              if (_inner_error_ != NULL) {
                     goto __catch6_g_error;
              }
              _g_regex_unref0 (self->priv->lens_dbusname_regex);
              self->priv->lens_dbusname_regex = _tmp1_;
       }
       goto __finally6;
       __catch6_g_error:
       {
              GError* e = NULL;
              FILE* _tmp2_;
              e = _inner_error_;
              _inner_error_ = NULL;
              _tmp2_ = stderr;
              fprintf (_tmp2_, "Error parsing lens_dbusname_regex");
              _g_error_free0 (e);
       }
       __finally6:
       if (_inner_error_ != NULL) {
              g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
              g_clear_error (&_inner_error_);
              return NULL;
       }
       return self;
}

Here is the caller graph for this function:

void unity_tester_dbus_lens_util_dbus_object_address_copy ( const UnityTesterDBusLensUtilDBusObjectAddress *  self,
UnityTesterDBusLensUtilDBusObjectAddress *  dest 
)

Definition at line 964 of file unity-tool-dbus-util.c.

                                                                                                                                                                 {
       const gchar* _tmp0_;
       gchar* _tmp1_;
       const gchar* _tmp2_;
       gchar* _tmp3_;
       _tmp0_ = (*self).dbus_name;
       _tmp1_ = g_strdup (_tmp0_);
       _g_free0 ((*dest).dbus_name);
       (*dest).dbus_name = _tmp1_;
       _tmp2_ = (*self).dbus_path;
       _tmp3_ = g_strdup (_tmp2_);
       _g_free0 ((*dest).dbus_path);
       (*dest).dbus_path = _tmp3_;
}

Here is the caller graph for this function:

void unity_tester_dbus_lens_util_dbus_object_address_destroy ( UnityTesterDBusLensUtilDBusObjectAddress *  self)

Definition at line 980 of file unity-tool-dbus-util.c.

                                                                                                              {
       _g_free0 ((*self).dbus_name);
       _g_free0 ((*self).dbus_path);
}

Here is the caller graph for this function:

UnityTesterDBusLensUtilDBusObjectAddress* unity_tester_dbus_lens_util_dbus_object_address_dup ( const UnityTesterDBusLensUtilDBusObjectAddress *  self)

Definition at line 986 of file unity-tool-dbus-util.c.

                                                                                                                                                     {
       UnityTesterDBusLensUtilDBusObjectAddress* dup;
       dup = g_new0 (UnityTesterDBusLensUtilDBusObjectAddress, 1);
       unity_tester_dbus_lens_util_dbus_object_address_copy (self, dup);
       return dup;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void unity_tester_dbus_lens_util_dbus_object_address_free ( UnityTesterDBusLensUtilDBusObjectAddress *  self)

Definition at line 994 of file unity-tool-dbus-util.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1000 of file unity-tool-dbus-util.c.

                                                                      {
       static volatile gsize unity_tester_dbus_lens_util_dbus_object_address_type_id__volatile = 0;
       if (g_once_init_enter (&unity_tester_dbus_lens_util_dbus_object_address_type_id__volatile)) {
              GType unity_tester_dbus_lens_util_dbus_object_address_type_id;
              unity_tester_dbus_lens_util_dbus_object_address_type_id = g_boxed_type_register_static ("UnityTesterDBusLensUtilDBusObjectAddress", (GBoxedCopyFunc) unity_tester_dbus_lens_util_dbus_object_address_dup, (GBoxedFreeFunc) unity_tester_dbus_lens_util_dbus_object_address_free);
              g_once_init_leave (&unity_tester_dbus_lens_util_dbus_object_address_type_id__volatile, unity_tester_dbus_lens_util_dbus_object_address_type_id);
       }
       return unity_tester_dbus_lens_util_dbus_object_address_type_id__volatile;
}

Here is the call graph for this function:

static void unity_tester_dbus_lens_util_finalize ( UnityTesterDBusLensUtil *  obj) [static]

Definition at line 1138 of file unity-tool-dbus-util.c.

                                                                                {
       UnityTesterDBusLensUtil * self;
       self = G_TYPE_CHECK_INSTANCE_CAST (obj, UNITY_TESTER_TYPE_DBUS_LENS_UTIL, UnityTesterDBusLensUtil);
       _g_regex_unref0 (self->priv->lens_dbusname_regex);
       _g_free0 (self->priv->current_dbus_name);
       _g_free0 (self->priv->current_dbus_path);
       __g_queue_free__unity_tester_dbus_lens_util_dbus_object_address_free0_0 (self->priv->nodes);
       __g_list_free__unity_tester_dbus_lens_util_dbus_object_address_free0_0 (self->priv->lenses);
}

Here is the caller graph for this function:

void unity_tester_dbus_lens_util_findLenses ( UnityTesterDBusLensUtil *  self,
GAsyncReadyCallback  _callback_,
gpointer  _user_data_ 
)

Definition at line 646 of file unity-tool-dbus-util.c.

                                                                                                                                  {
       unity_tester_dbus_lens_util_findLensesData* _data_;
       UnityTesterDBusLensUtil* _tmp0_;
       _data_ = g_slice_new0 (unity_tester_dbus_lens_util_findLensesData);
       _data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, unity_tester_dbus_lens_util_findLenses);
       g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, unity_tester_dbus_lens_util_findLenses_data_free);
       _tmp0_ = _unity_tester_dbus_lens_util_ref0 (self);
       _data_->self = _tmp0_;
       unity_tester_dbus_lens_util_findLenses_co (_data_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean unity_tester_dbus_lens_util_findLenses_co ( unity_tester_dbus_lens_util_findLensesData *  _data_) [static]

Definition at line 686 of file unity-tool-dbus-util.c.

                                                                                                               {
       switch (_data_->_state_) {
              case 0:
              goto _state_0;
              case 1:
              goto _state_1;
              default:
              g_assert_not_reached ();
       }
       _state_0:
       _data_->_tmp0_ = _data_->self->priv->lens_dbusname_regex;
       if (_data_->_tmp0_ == NULL) {
              _data_->_tmp1_ = stderr;
              fprintf (_data_->_tmp1_, "Invalid lens_dbusname_regex");
              _data_->_tmp2_ = _data_->self->priv->lenses;
              _data_->result = _data_->_tmp2_;
              if (_data_->_state_ == 0) {
                     g_simple_async_result_complete_in_idle (_data_->_async_result);
              } else {
                     g_simple_async_result_complete (_data_->_async_result);
              }
              g_object_unref (_data_->_async_result);
              return FALSE;
       }
       _data_->_tmp3_ = NULL;
       _data_->_tmp3_ = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &_data_->_inner_error_);
       _data_->bus = _data_->_tmp3_;
       if (_data_->_inner_error_ != NULL) {
              g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
              g_error_free (_data_->_inner_error_);
              if (_data_->_state_ == 0) {
                     g_simple_async_result_complete_in_idle (_data_->_async_result);
              } else {
                     g_simple_async_result_complete (_data_->_async_result);
              }
              g_object_unref (_data_->_async_result);
              return FALSE;
       }
       _data_->_tmp4_ = g_variant_type_new ("(s)");
       _data_->vt = _data_->_tmp4_;
       _data_->_tmp5_ = NULL;
       _data_->_tmp5_ = unity_tester_dbus_lens_util_getServices (_data_->self, &_data_->_inner_error_);
       _data_->_tmp6_ = _data_->_tmp5_;
       if (_data_->_inner_error_ != NULL) {
              g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
              g_error_free (_data_->_inner_error_);
              _g_variant_type_free0 (_data_->vt);
              _g_object_unref0 (_data_->bus);
              if (_data_->_state_ == 0) {
                     g_simple_async_result_complete_in_idle (_data_->_async_result);
              } else {
                     g_simple_async_result_complete (_data_->_async_result);
              }
              g_object_unref (_data_->_async_result);
              return FALSE;
       }
       {
              _data_->srv_collection = _data_->_tmp6_;
              for (_data_->srv_it = _data_->srv_collection; _data_->srv_it != NULL; _data_->srv_it = _data_->srv_it->next) {
                     _data_->_tmp7_ = g_strdup ((const gchar*) _data_->srv_it->data);
                     _data_->srv = _data_->_tmp7_;
                     {
                            _data_->_tmp8_ = _data_->self->priv->lens_dbusname_regex;
                            _data_->_tmp9_ = _data_->srv;
                            _data_->_tmp10_ = FALSE;
                            _data_->_tmp10_ = g_regex_match (_data_->_tmp8_, _data_->_tmp9_, 0, NULL);
                            if (_data_->_tmp10_) {
                                   {
                                          _data_->_tmp11_ = g_variant_type_new ("(s)");
                                          _data_->_tmp12_ = _data_->_tmp11_;
                                          _data_->_tmp13_ = g_variant_builder_new (_data_->_tmp12_);
                                          _data_->_tmp14_ = _data_->_tmp13_;
                                          _g_variant_type_free0 (_data_->_tmp12_);
                                          _data_->vb = _data_->_tmp14_;
                                          _data_->_tmp15_ = _data_->vb;
                                          _data_->_tmp16_ = _data_->srv;
                                          _data_->_tmp17_ = _variant_new2 (_data_->_tmp16_);
                                          g_variant_builder_add_value (_data_->_tmp15_, _data_->_tmp17_);
                                          _data_->_tmp18_ = _data_->bus;
                                          _data_->_tmp19_ = _data_->vb;
                                          _data_->_tmp20_ = NULL;
                                          _data_->_tmp20_ = g_variant_builder_end (_data_->_tmp19_);
                                          g_variant_ref_sink (_data_->_tmp20_);
                                          _data_->_tmp21_ = _data_->_tmp20_;
                                          _data_->_tmp22_ = _data_->vt;
                                          _data_->_tmp23_ = NULL;
                                          _data_->_tmp23_ = g_dbus_connection_call_sync (_data_->_tmp18_, "org.freedesktop.DBus", "/", "org.freedesktop.DBus", "GetNameOwner", _data_->_tmp21_, _data_->_tmp22_, 0, 10, NULL, &_data_->_inner_error_);
                                          _data_->_tmp24_ = _data_->_tmp23_;
                                          _g_variant_unref0 (_data_->_tmp21_);
                                          _data_->v = _data_->_tmp24_;
                                          if (_data_->_inner_error_ != NULL) {
                                                 _g_variant_builder_unref0 (_data_->vb);
                                                 goto __catch7_g_error;
                                          }
                                          _data_->_tmp25_ = _data_->v;
                                          if (_data_->_tmp25_ != NULL) {
                                                 _data_->_tmp26_ = _data_->v;
                                                 _data_->_tmp27_ = NULL;
                                                 _data_->_tmp27_ = g_variant_get_child_value (_data_->_tmp26_, (gsize) 0);
                                                 _data_->_tmp28_ = _data_->_tmp27_;
                                                 _data_->_tmp29_ = NULL;
                                                 _data_->_tmp29_ = g_variant_get_string (_data_->_tmp28_, NULL);
                                                 _data_->_tmp30_ = g_strdup (_data_->_tmp29_);
                                                 _data_->_tmp31_ = _data_->_tmp30_;
                                                 _g_variant_unref0 (_data_->_tmp28_);
                                                 _data_->owner = _data_->_tmp31_;
                                                 _data_->_tmp32_ = _data_->owner;
                                                 if (_data_->_tmp32_ != NULL) {
                                                        _data_->_tmp33_ = _data_->owner;
                                                        _data_->_tmp34_ = g_strdup (_data_->_tmp33_);
                                                        _data_->_tmp35_ = g_strdup ("/");
                                                        memset (&_data_->_tmp36_, 0, sizeof (UnityTesterDBusLensUtilDBusObjectAddress));
                                                        memset (&_data_->_tmp36_, 0, sizeof (UnityTesterDBusLensUtilDBusObjectAddress));
                                                        _g_free0 (_data_->_tmp36_.dbus_name);
                                                        _data_->_tmp36_.dbus_name = _data_->_tmp34_;
                                                        _g_free0 (_data_->_tmp36_.dbus_path);
                                                        _data_->_tmp36_.dbus_path = _data_->_tmp35_;
                                                        _data_->obj = _data_->_tmp36_;
                                                        _data_->_tmp37_ = _data_->self->priv->nodes;
                                                        _data_->_tmp38_ = _data_->obj;
                                                        _data_->_tmp39_ = _data_->_tmp38_;
                                                        _data_->_tmp40_ = _unity_tester_dbus_lens_util_dbus_object_address_dup0 (&_data_->_tmp39_);
                                                        g_queue_push_tail (_data_->_tmp37_, _data_->_tmp40_);
                                                        unity_tester_dbus_lens_util_dbus_object_address_destroy (&_data_->obj);
                                                 }
                                                 _g_free0 (_data_->owner);
                                          }
                                          _g_variant_unref0 (_data_->v);
                                          _g_variant_builder_unref0 (_data_->vb);
                                   }
                                   goto __finally7;
                                   __catch7_g_error:
                                   {
                                          _data_->e = _data_->_inner_error_;
                                          _data_->_inner_error_ = NULL;
                                          _g_error_free0 (_data_->e);
                                   }
                                   __finally7:
                                   if (_data_->_inner_error_ != NULL) {
                                          g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
                                          g_error_free (_data_->_inner_error_);
                                          _g_free0 (_data_->srv);
                                          __g_list_free__g_free0_0 (_data_->srv_collection);
                                          _g_variant_type_free0 (_data_->vt);
                                          _g_object_unref0 (_data_->bus);
                                          if (_data_->_state_ == 0) {
                                                 g_simple_async_result_complete_in_idle (_data_->_async_result);
                                          } else {
                                                 g_simple_async_result_complete (_data_->_async_result);
                                          }
                                          g_object_unref (_data_->_async_result);
                                          return FALSE;
                                   }
                            }
                            _g_free0 (_data_->srv);
                     }
              }
              __g_list_free__g_free0_0 (_data_->srv_collection);
       }
       while (TRUE) {
              _data_->_tmp41_ = _data_->self->priv->nodes;
              _data_->_tmp42_ = _data_->_tmp41_->length;
              if (!(_data_->_tmp42_ > ((guint) 0))) {
                     break;
              }
              _data_->_tmp43_ = _data_->self->priv->nodes;
              _data_->_tmp44_ = NULL;
              _data_->_tmp44_ = g_queue_pop_head (_data_->_tmp43_);
              _data_->_tmp45_ = (UnityTesterDBusLensUtilDBusObjectAddress*) _data_->_tmp44_;
              memset (&_data_->_tmp46_, 0, sizeof (UnityTesterDBusLensUtilDBusObjectAddress));
              unity_tester_dbus_lens_util_dbus_object_address_copy (_data_->_tmp45_, &_data_->_tmp46_);
              _data_->_tmp47_ = _data_->_tmp46_;
              _unity_tester_dbus_lens_util_dbus_object_address_free0 (_data_->_tmp45_);
              _data_->node = _data_->_tmp47_;
              _data_->_tmp48_ = _data_->node;
              _data_->_tmp49_ = _data_->_tmp48_.dbus_name;
              _data_->_tmp50_ = g_strdup (_data_->_tmp49_);
              _g_free0 (_data_->self->priv->current_dbus_name);
              _data_->self->priv->current_dbus_name = _data_->_tmp50_;
              _data_->_tmp51_ = _data_->node;
              _data_->_tmp52_ = _data_->_tmp51_.dbus_path;
              _data_->_tmp53_ = g_strdup (_data_->_tmp52_);
              _g_free0 (_data_->self->priv->current_dbus_path);
              _data_->self->priv->current_dbus_path = _data_->_tmp53_;
              {
                     _data_->_tmp54_ = _data_->bus;
                     _data_->_tmp55_ = _data_->self->priv->current_dbus_name;
                     _data_->_tmp56_ = _data_->self->priv->current_dbus_path;
                     _data_->_tmp57_ = _data_->vt;
                     _data_->_tmp58_ = NULL;
                     _data_->_tmp58_ = g_dbus_connection_call_sync (_data_->_tmp54_, _data_->_tmp55_, _data_->_tmp56_, "org.freedesktop.DBus.Introspectable", "Introspect", NULL, _data_->_tmp57_, 0, 10, NULL, &_data_->_inner_error_);
                     _data_->_vala1_v = _data_->_tmp58_;
                     if (_data_->_inner_error_ != NULL) {
                            goto __catch8_g_error;
                     }
                     _data_->_tmp59_ = _data_->_vala1_v;
                     if (_data_->_tmp59_ != NULL) {
                            _data_->_tmp60_ = _data_->_vala1_v;
                            _data_->_tmp61_ = NULL;
                            _data_->_tmp61_ = g_variant_get_child_value (_data_->_tmp60_, (gsize) 0);
                            _data_->_tmp62_ = _data_->_tmp61_;
                            _data_->_tmp63_ = NULL;
                            _data_->_tmp63_ = g_variant_get_string (_data_->_tmp62_, NULL);
                            _data_->_tmp64_ = g_strdup (_data_->_tmp63_);
                            _data_->_tmp65_ = _data_->_tmp64_;
                            _g_variant_unref0 (_data_->_tmp62_);
                            _data_->xmldata = _data_->_tmp65_;
                            _data_->_tmp66_ = g_markup_parse_context_new (&UNITY_TESTER_DBUS_LENS_UTIL_parser, G_MARKUP_TREAT_CDATA_AS_TEXT, _data_->self, NULL);
                            _data_->context = _data_->_tmp66_;
                            _data_->_tmp67_ = _data_->context;
                            _data_->_tmp68_ = _data_->xmldata;
                            _data_->_tmp69_ = _data_->xmldata;
                            _data_->_tmp70_ = strlen (_data_->_tmp69_);
                            _data_->_tmp71_ = _data_->_tmp70_;
                            g_markup_parse_context_parse (_data_->_tmp67_, _data_->_tmp68_, (gssize) _data_->_tmp71_, &_data_->_inner_error_);
                            if (_data_->_inner_error_ != NULL) {
                                   _g_markup_parse_context_free0 (_data_->context);
                                   _g_free0 (_data_->xmldata);
                                   _g_variant_unref0 (_data_->_vala1_v);
                                   goto __catch8_g_error;
                            }
                            _g_markup_parse_context_free0 (_data_->context);
                            _g_free0 (_data_->xmldata);
                     }
                     _g_variant_unref0 (_data_->_vala1_v);
              }
              goto __finally8;
              __catch8_g_error:
              {
                     _data_->_vala1_e = _data_->_inner_error_;
                     _data_->_inner_error_ = NULL;
                     _g_error_free0 (_data_->_vala1_e);
              }
              __finally8:
              if (_data_->_inner_error_ != NULL) {
                     g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
                     g_error_free (_data_->_inner_error_);
                     unity_tester_dbus_lens_util_dbus_object_address_destroy (&_data_->node);
                     _g_variant_type_free0 (_data_->vt);
                     _g_object_unref0 (_data_->bus);
                     if (_data_->_state_ == 0) {
                            g_simple_async_result_complete_in_idle (_data_->_async_result);
                     } else {
                            g_simple_async_result_complete (_data_->_async_result);
                     }
                     g_object_unref (_data_->_async_result);
                     return FALSE;
              }
              g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, _unity_tester_dbus_lens_util_findLenses_co_gsource_func, _data_, NULL);
              _data_->_state_ = 1;
              return FALSE;
              _state_1:
              ;
              unity_tester_dbus_lens_util_dbus_object_address_destroy (&_data_->node);
       }
       _data_->_tmp72_ = _data_->self->priv->lenses;
       _data_->result = _data_->_tmp72_;
       _g_variant_type_free0 (_data_->vt);
       _g_object_unref0 (_data_->bus);
       if (_data_->_state_ == 0) {
              g_simple_async_result_complete_in_idle (_data_->_async_result);
       } else {
              g_simple_async_result_complete (_data_->_async_result);
       }
       g_object_unref (_data_->_async_result);
       return FALSE;
       _g_variant_type_free0 (_data_->vt);
       _g_object_unref0 (_data_->bus);
       if (_data_->_state_ == 0) {
              g_simple_async_result_complete_in_idle (_data_->_async_result);
       } else {
              g_simple_async_result_complete (_data_->_async_result);
       }
       g_object_unref (_data_->_async_result);
       return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unity_tester_dbus_lens_util_findLenses_data_free ( gpointer  _data) [static]

Definition at line 633 of file unity-tool-dbus-util.c.

                                                                              {
       unity_tester_dbus_lens_util_findLensesData* _data_;
       _data_ = _data;
       _unity_tester_dbus_lens_util_unref0 (_data_->self);
       g_slice_free (unity_tester_dbus_lens_util_findLensesData, _data_);
}

Here is the caller graph for this function:

GList * unity_tester_dbus_lens_util_findLenses_finish ( UnityTesterDBusLensUtil *  self,
GAsyncResult *  _res_,
GError **  error 
)

Definition at line 658 of file unity-tool-dbus-util.c.

                                                                                                                          {
       GList* result;
       unity_tester_dbus_lens_util_findLensesData* _data_;
       if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
              return NULL;
       }
       _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
       result = _data_->result;
       _data_->result = NULL;
       return result;
}

Here is the caller graph for this function:

Definition at line 178 of file unity-tool-dbus-util.c.

      {
       UNITY_TESTER_DBUS_LENS_UTIL_DUMMY_PROPERTY
};
static GList * unity_tester_dbus_lens_util_getServices ( UnityTesterDBusLensUtil *  self,
GError **  error 
) [static]

Definition at line 288 of file unity-tool-dbus-util.c.

                                                                                                      {
       GList* result = NULL;
       GList* services;
       GVariantType* _tmp0_;
       GVariantType* vt;
       GDBusConnection* _tmp1_ = NULL;
       GDBusConnection* bus;
       GDBusConnection* _tmp2_;
       const GVariantType* _tmp3_;
       GVariant* _tmp4_ = NULL;
       GVariant* v;
       GVariant* _tmp5_;
       GVariant* _tmp6_ = NULL;
       GVariant* _tmp7_;
       size_t _tmp8_;
       const gchar** _tmp9_ = NULL;
       const gchar** _tmp10_;
       gint _tmp10__length1;
       const gchar** names;
       gint names_length1;
       gint _names_size_;
       const gchar** _tmp11_;
       gint _tmp11__length1;
       GError * _inner_error_ = NULL;
       g_return_val_if_fail (self != NULL, NULL);
       services = NULL;
       _tmp0_ = g_variant_type_new ("(as)");
       vt = _tmp0_;
       _tmp1_ = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &_inner_error_);
       bus = _tmp1_;
       if (_inner_error_ != NULL) {
              g_propagate_error (error, _inner_error_);
              _g_variant_type_free0 (vt);
              __g_list_free__g_free0_0 (services);
              return NULL;
       }
       _tmp2_ = bus;
       _tmp3_ = vt;
       _tmp4_ = g_dbus_connection_call_sync (_tmp2_, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames", NULL, _tmp3_, 0, -1, NULL, &_inner_error_);
       v = _tmp4_;
       if (_inner_error_ != NULL) {
              g_propagate_error (error, _inner_error_);
              _g_object_unref0 (bus);
              _g_variant_type_free0 (vt);
              __g_list_free__g_free0_0 (services);
              return NULL;
       }
       _tmp5_ = v;
       _tmp6_ = g_variant_get_child_value (_tmp5_, (gsize) 0);
       _tmp7_ = _tmp6_;
       _tmp9_ = g_variant_get_strv (_tmp7_, &_tmp8_);
       _tmp10_ = _tmp9_;
       _tmp10__length1 = _tmp8_;
       _g_variant_unref0 (_tmp7_);
       names = _tmp10_;
       names_length1 = _tmp10__length1;
       _names_size_ = names_length1;
       _tmp11_ = names;
       _tmp11__length1 = names_length1;
       {
              const gchar** s_collection = NULL;
              gint s_collection_length1 = 0;
              gint _s_collection_size_ = 0;
              gint s_it = 0;
              s_collection = _tmp11_;
              s_collection_length1 = _tmp11__length1;
              for (s_it = 0; s_it < _tmp11__length1; s_it = s_it + 1) {
                     const gchar* s = NULL;
                     s = s_collection[s_it];
                     {
                            const gchar* _tmp12_;
                            gchar* _tmp13_;
                            _tmp12_ = s;
                            _tmp13_ = g_strdup ((gchar*) _tmp12_);
                            services = g_list_append (services, _tmp13_);
                     }
              }
       }
       result = services;
       names = (g_free (names), NULL);
       _g_variant_unref0 (v);
       _g_object_unref0 (bus);
       _g_variant_type_free0 (vt);
       return result;
}

Here is the caller graph for this function:

static void unity_tester_dbus_lens_util_instance_init ( UnityTesterDBusLensUtil *  self) [static]

Definition at line 1128 of file unity-tool-dbus-util.c.

                                                                                       {
       GQueue* _tmp0_;
       self->priv = UNITY_TESTER_DBUS_LENS_UTIL_GET_PRIVATE (self);
       _tmp0_ = g_queue_new ();
       self->priv->nodes = _tmp0_;
       self->priv->lenses = NULL;
       self->ref_count = 1;
}
UnityTesterDBusLensUtil * unity_tester_dbus_lens_util_new ( void  )

Definition at line 269 of file unity-tool-dbus-util.c.

Here is the call graph for this function:

Here is the caller graph for this function:

gpointer unity_tester_dbus_lens_util_ref ( gpointer  instance)

Definition at line 1163 of file unity-tool-dbus-util.c.

                                                             {
       UnityTesterDBusLensUtil* self;
       self = instance;
       g_atomic_int_inc (&self->ref_count);
       return instance;
}

Here is the caller graph for this function:

static void unity_tester_dbus_lens_util_start ( UnityTesterDBusLensUtil *  self,
GMarkupParseContext *  context,
const gchar *  name,
gchar **  attr_names,
int  attr_names_length1,
gchar **  attr_values,
int  attr_values_length1,
GError **  error 
) [static]

Definition at line 426 of file unity-tool-dbus-util.c.

                                                                                                                                                                                                                                         {
       const gchar* _tmp0_;
       const gchar* _tmp32_;
       g_return_if_fail (self != NULL);
       g_return_if_fail (context != NULL);
       g_return_if_fail (name != NULL);
       _tmp0_ = name;
       if (g_strcmp0 (_tmp0_, "node") == 0) {
              {
                     gint i;
                     i = 0;
                     {
                            gboolean _tmp1_;
                            _tmp1_ = TRUE;
                            while (TRUE) {
                                   gboolean _tmp2_;
                                   gint _tmp4_;
                                   gchar** _tmp5_;
                                   gint _tmp5__length1;
                                   gchar** _tmp6_;
                                   gint _tmp6__length1;
                                   gint _tmp7_;
                                   const gchar* _tmp8_;
                                   _tmp2_ = _tmp1_;
                                   if (!_tmp2_) {
                                          gint _tmp3_;
                                          _tmp3_ = i;
                                          i = _tmp3_ + 1;
                                   }
                                   _tmp1_ = FALSE;
                                   _tmp4_ = i;
                                   _tmp5_ = attr_names;
                                   _tmp5__length1 = attr_names_length1;
                                   if (!(_tmp4_ < _tmp5__length1)) {
                                          break;
                                   }
                                   _tmp6_ = attr_names;
                                   _tmp6__length1 = attr_names_length1;
                                   _tmp7_ = i;
                                   _tmp8_ = _tmp6_[_tmp7_];
                                   if (g_strcmp0 (_tmp8_, "name") == 0) {
                                          gchar* _tmp9_ = NULL;
                                          const gchar* _tmp10_;
                                          gboolean _tmp11_ = FALSE;
                                          const gchar* _tmp20_;
                                          gchar* _tmp21_;
                                          gchar* node_path;
                                          const gchar* _tmp22_;
                                          gchar* _tmp23_;
                                          const gchar* _tmp24_;
                                          const gchar* _tmp25_;
                                          gchar* _tmp26_;
                                          UnityTesterDBusLensUtilDBusObjectAddress _tmp27_ = {0};
                                          UnityTesterDBusLensUtilDBusObjectAddress obj;
                                          GQueue* _tmp28_;
                                          UnityTesterDBusLensUtilDBusObjectAddress _tmp29_;
                                          UnityTesterDBusLensUtilDBusObjectAddress _tmp30_;
                                          UnityTesterDBusLensUtilDBusObjectAddress* _tmp31_;
                                          _tmp10_ = self->priv->current_dbus_path;
                                          _tmp11_ = g_str_has_suffix (_tmp10_, "/");
                                          if (_tmp11_) {
                                                 gchar** _tmp12_;
                                                 gint _tmp12__length1;
                                                 gint _tmp13_;
                                                 const gchar* _tmp14_;
                                                 gchar* _tmp15_;
                                                 _tmp12_ = attr_values;
                                                 _tmp12__length1 = attr_values_length1;
                                                 _tmp13_ = i;
                                                 _tmp14_ = _tmp12_[_tmp13_];
                                                 _tmp15_ = g_strdup (_tmp14_);
                                                 _g_free0 (_tmp9_);
                                                 _tmp9_ = _tmp15_;
                                          } else {
                                                 gchar** _tmp16_;
                                                 gint _tmp16__length1;
                                                 gint _tmp17_;
                                                 const gchar* _tmp18_;
                                                 gchar* _tmp19_;
                                                 _tmp16_ = attr_values;
                                                 _tmp16__length1 = attr_values_length1;
                                                 _tmp17_ = i;
                                                 _tmp18_ = _tmp16_[_tmp17_];
                                                 _tmp19_ = g_strconcat ("/", _tmp18_, NULL);
                                                 _g_free0 (_tmp9_);
                                                 _tmp9_ = _tmp19_;
                                          }
                                          _tmp20_ = _tmp9_;
                                          _tmp21_ = g_strdup (_tmp20_);
                                          node_path = _tmp21_;
                                          _tmp22_ = self->priv->current_dbus_name;
                                          _tmp23_ = g_strdup (_tmp22_);
                                          _tmp24_ = self->priv->current_dbus_path;
                                          _tmp25_ = node_path;
                                          _tmp26_ = g_strconcat (_tmp24_, _tmp25_, NULL);
                                          memset (&_tmp27_, 0, sizeof (UnityTesterDBusLensUtilDBusObjectAddress));
                                          _g_free0 (_tmp27_.dbus_name);
                                          _tmp27_.dbus_name = _tmp23_;
                                          _g_free0 (_tmp27_.dbus_path);
                                          _tmp27_.dbus_path = _tmp26_;
                                          obj = _tmp27_;
                                          _tmp28_ = self->priv->nodes;
                                          _tmp29_ = obj;
                                          _tmp30_ = _tmp29_;
                                          _tmp31_ = _unity_tester_dbus_lens_util_dbus_object_address_dup0 (&_tmp30_);
                                          g_queue_push_tail (_tmp28_, _tmp31_);
                                          unity_tester_dbus_lens_util_dbus_object_address_destroy (&obj);
                                          _g_free0 (node_path);
                                          _g_free0 (_tmp9_);
                                   }
                            }
                     }
              }
       }
       _tmp32_ = name;
       if (g_strcmp0 (_tmp32_, "interface") == 0) {
              {
                     gint i;
                     i = 0;
                     {
                            gboolean _tmp33_;
                            _tmp33_ = TRUE;
                            while (TRUE) {
                                   gboolean _tmp34_;
                                   gint _tmp36_;
                                   gchar** _tmp37_;
                                   gint _tmp37__length1;
                                   gboolean _tmp38_ = FALSE;
                                   gchar** _tmp39_;
                                   gint _tmp39__length1;
                                   gint _tmp40_;
                                   const gchar* _tmp41_;
                                   gboolean _tmp45_;
                                   _tmp34_ = _tmp33_;
                                   if (!_tmp34_) {
                                          gint _tmp35_;
                                          _tmp35_ = i;
                                          i = _tmp35_ + 1;
                                   }
                                   _tmp33_ = FALSE;
                                   _tmp36_ = i;
                                   _tmp37_ = attr_names;
                                   _tmp37__length1 = attr_names_length1;
                                   if (!(_tmp36_ < _tmp37__length1)) {
                                          break;
                                   }
                                   _tmp39_ = attr_names;
                                   _tmp39__length1 = attr_names_length1;
                                   _tmp40_ = i;
                                   _tmp41_ = _tmp39_[_tmp40_];
                                   if (g_strcmp0 (_tmp41_, "name") == 0) {
                                          gchar** _tmp42_;
                                          gint _tmp42__length1;
                                          gint _tmp43_;
                                          const gchar* _tmp44_;
                                          _tmp42_ = attr_values;
                                          _tmp42__length1 = attr_values_length1;
                                          _tmp43_ = i;
                                          _tmp44_ = _tmp42_[_tmp43_];
                                          _tmp38_ = g_strcmp0 (_tmp44_, "com.canonical.Unity.Lens") == 0;
                                   } else {
                                          _tmp38_ = FALSE;
                                   }
                                   _tmp45_ = _tmp38_;
                                   if (_tmp45_) {
                                          const gchar* _tmp46_;
                                          gchar* _tmp47_;
                                          const gchar* _tmp48_;
                                          gchar* _tmp49_;
                                          UnityTesterDBusLensUtilDBusObjectAddress _tmp50_ = {0};
                                          UnityTesterDBusLensUtilDBusObjectAddress obj;
                                          GList* _tmp51_;
                                          UnityTesterDBusLensUtilDBusObjectAddress _tmp52_;
                                          GList* _tmp53_ = NULL;
                                          guint _tmp54_ = 0U;
                                          _tmp46_ = self->priv->current_dbus_name;
                                          _tmp47_ = g_strdup (_tmp46_);
                                          _tmp48_ = self->priv->current_dbus_path;
                                          _tmp49_ = g_strdup (_tmp48_);
                                          memset (&_tmp50_, 0, sizeof (UnityTesterDBusLensUtilDBusObjectAddress));
                                          _g_free0 (_tmp50_.dbus_name);
                                          _tmp50_.dbus_name = _tmp47_;
                                          _g_free0 (_tmp50_.dbus_path);
                                          _tmp50_.dbus_path = _tmp49_;
                                          obj = _tmp50_;
                                          _tmp51_ = self->priv->lenses;
                                          _tmp52_ = obj;
                                          _tmp53_ = g_list_find_custom (_tmp51_, &_tmp52_, ________lambda2__gcompare_func);
                                          _tmp54_ = g_list_length (_tmp53_);
                                          if (_tmp54_ == ((guint) 0)) {
                                                 UnityTesterDBusLensUtilDBusObjectAddress _tmp55_;
                                                 UnityTesterDBusLensUtilDBusObjectAddress _tmp56_;
                                                 UnityTesterDBusLensUtilDBusObjectAddress* _tmp57_;
                                                 _tmp55_ = obj;
                                                 _tmp56_ = _tmp55_;
                                                 _tmp57_ = _unity_tester_dbus_lens_util_dbus_object_address_dup0 (&_tmp56_);
                                                 self->priv->lenses = g_list_append (self->priv->lenses, _tmp57_);
                                          }
                                          unity_tester_dbus_lens_util_dbus_object_address_destroy (&obj);
                                   }
                            }
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void unity_tester_dbus_lens_util_unref ( gpointer  instance)

Definition at line 1171 of file unity-tool-dbus-util.c.

                                                           {
       UnityTesterDBusLensUtil* self;
       self = instance;
       if (g_atomic_int_dec_and_test (&self->ref_count)) {
              UNITY_TESTER_DBUS_LENS_UTIL_GET_CLASS (self)->finalize (self);
              g_type_free_instance ((GTypeInstance *) self);
       }
}

Here is the caller graph for this function:

GParamSpec * unity_tester_param_spec_dbus_lens_util ( const gchar *  name,
const gchar *  nick,
const gchar *  blurb,
GType  object_type,
GParamFlags  flags 
)

Definition at line 1071 of file unity-tool-dbus-util.c.

                                                                                                                                                    {
       UnityTesterParamSpecDBusLensUtil* spec;
       g_return_val_if_fail (g_type_is_a (object_type, UNITY_TESTER_TYPE_DBUS_LENS_UTIL), NULL);
       spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
       G_PARAM_SPEC (spec)->value_type = object_type;
       return G_PARAM_SPEC (spec);
}
static gchar* unity_tester_value_dbus_lens_util_collect_value ( GValue *  value,
guint  n_collect_values,
GTypeCValue *  collect_values,
guint  collect_flags 
) [static]

Definition at line 1037 of file unity-tool-dbus-util.c.

                                                                                                                                                        {
       if (collect_values[0].v_pointer) {
              UnityTesterDBusLensUtil* object;
              object = collect_values[0].v_pointer;
              if (object->parent_instance.g_class == NULL) {
                     return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
              } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                     return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
              }
              value->data[0].v_pointer = unity_tester_dbus_lens_util_ref (object);
       } else {
              value->data[0].v_pointer = NULL;
       }
       return NULL;
}

Here is the call graph for this function:

static void unity_tester_value_dbus_lens_util_copy_value ( const GValue *  src_value,
GValue *  dest_value 
) [static]

Definition at line 1023 of file unity-tool-dbus-util.c.

                                                                                                       {
       if (src_value->data[0].v_pointer) {
              dest_value->data[0].v_pointer = unity_tester_dbus_lens_util_ref (src_value->data[0].v_pointer);
       } else {
              dest_value->data[0].v_pointer = NULL;
       }
}

Here is the call graph for this function:

static void unity_tester_value_dbus_lens_util_free_value ( GValue *  value) [static]

Definition at line 1016 of file unity-tool-dbus-util.c.

                                                                         {
       if (value->data[0].v_pointer) {
              unity_tester_dbus_lens_util_unref (value->data[0].v_pointer);
       }
}

Here is the call graph for this function:

static void unity_tester_value_dbus_lens_util_init ( GValue *  value) [static]

Definition at line 1011 of file unity-tool-dbus-util.c.

                                                                   {
       value->data[0].v_pointer = NULL;
}
static gchar* unity_tester_value_dbus_lens_util_lcopy_value ( const GValue *  value,
guint  n_collect_values,
GTypeCValue *  collect_values,
guint  collect_flags 
) [static]

Definition at line 1054 of file unity-tool-dbus-util.c.

                                                                                                                                                            {
       UnityTesterDBusLensUtil** object_p;
       object_p = collect_values[0].v_pointer;
       if (!object_p) {
              return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
       }
       if (!value->data[0].v_pointer) {
              *object_p = NULL;
       } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
              *object_p = value->data[0].v_pointer;
       } else {
              *object_p = unity_tester_dbus_lens_util_ref (value->data[0].v_pointer);
       }
       return NULL;
}

Here is the call graph for this function:

static gpointer unity_tester_value_dbus_lens_util_peek_pointer ( const GValue *  value) [static]

Definition at line 1032 of file unity-tool-dbus-util.c.

                                                                                     {
       return value->data[0].v_pointer;
}
gpointer unity_tester_value_get_dbus_lens_util ( const GValue *  value)

Definition at line 1080 of file unity-tool-dbus-util.c.

                                                                     {
       g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, UNITY_TESTER_TYPE_DBUS_LENS_UTIL), NULL);
       return value->data[0].v_pointer;
}
void unity_tester_value_set_dbus_lens_util ( GValue *  value,
gpointer  v_object 
)

Definition at line 1086 of file unity-tool-dbus-util.c.

                                                                              {
       UnityTesterDBusLensUtil* old;
       g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, UNITY_TESTER_TYPE_DBUS_LENS_UTIL));
       old = value->data[0].v_pointer;
       if (v_object) {
              g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, UNITY_TESTER_TYPE_DBUS_LENS_UTIL));
              g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
              value->data[0].v_pointer = v_object;
              unity_tester_dbus_lens_util_ref (value->data[0].v_pointer);
       } else {
              value->data[0].v_pointer = NULL;
       }
       if (old) {
              unity_tester_dbus_lens_util_unref (old);
       }
}

Here is the call graph for this function:

void unity_tester_value_take_dbus_lens_util ( GValue *  value,
gpointer  v_object 
)

Definition at line 1104 of file unity-tool-dbus-util.c.

                                                                               {
       UnityTesterDBusLensUtil* old;
       g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, UNITY_TESTER_TYPE_DBUS_LENS_UTIL));
       old = value->data[0].v_pointer;
       if (v_object) {
              g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, UNITY_TESTER_TYPE_DBUS_LENS_UTIL));
              g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
              value->data[0].v_pointer = v_object;
       } else {
              value->data[0].v_pointer = NULL;
       }
       if (old) {
              unity_tester_dbus_lens_util_unref (old);
       }
}

Here is the call graph for this function:


Variable Documentation

gpointer unity_tester_dbus_lens_util_parent_class = NULL [static]

Definition at line 170 of file unity-tool-dbus-util.c.

Definition at line 209 of file unity-tool-dbus-util.c.