← Back to branch summary

~ubuntu-branches/ubuntu/quantal/folks/quantal

« back to all changes in this revision

Viewing changes to tools/inspect/command-backends.c

  • Committer: Package Import Robot
  • Author(s): Robert Ancell
  • Date: 2012-09-12 09:48:10 UTC
  • mfrom: (1.6.2)
  • Revision ID: package-import@ubuntu.com-20120912094810-6zlx8889hcovxj7p
Tags: 0.7.4.1-0ubuntu1
* New upstream bugfix release
* debian/control:
  - Bump build-depends on libglib2.0-dev, valac-0.18, libvala-0.18-dev
* debian/libfolks-eds25.symbols:
* debian/libfolks25.symbols:
  - Updated

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/inspect/command-backends.c
1
 
/* command-backends.c generated by valac 0.17.3, the Vala compiler
 
1
/* command-backends.c generated by valac 0.17.6.5-65f99, the Vala compiler
2
2
 * generated from command-backends.vala, do not modify */
3
3
 
4
4
/*
23
23
 
24
24
#include <glib.h>
25
25
#include <glib-object.h>
 
26
#include <gio/gio.h>
26
27
#include <stdlib.h>
27
28
#include <string.h>
28
29
#include <folks/folks.h>
62
63
typedef struct _FolksInspectCommandsBackends FolksInspectCommandsBackends;
63
64
typedef struct _FolksInspectCommandsBackendsClass FolksInspectCommandsBackendsClass;
64
65
typedef struct _FolksInspectCommandsBackendsPrivate FolksInspectCommandsBackendsPrivate;
 
66
#define _g_free0(var) (var = (g_free (var), NULL))
 
67
#define _folks_inspect_command_unref0(var) ((var == NULL) ? NULL : (var = (folks_inspect_command_unref (var), NULL)))
65
68
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
69
typedef struct _FolksInspectCommandsBackendsRunData FolksInspectCommandsBackendsRunData;
66
70
 
67
71
struct _FolksInspectCommand {
68
72
        GTypeInstance parent_instance;
74
78
struct _FolksInspectCommandClass {
75
79
        GTypeClass parent_class;
76
80
        void (*finalize) (FolksInspectCommand *self);
77
 
        void (*run) (FolksInspectCommand* self, const gchar* command_string);
 
81
        void (*run) (FolksInspectCommand* self, const gchar* command_string, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
82
        void (*run_finish) (FolksInspectCommand* self, GAsyncResult* _res_);
78
83
        gchar** (*complete_subcommand) (FolksInspectCommand* self, const gchar* subcommand, int* result_length1);
79
84
        const gchar* (*get_name) (FolksInspectCommand* self);
80
85
        const gchar* (*get_description) (FolksInspectCommand* self);
90
95
        FolksInspectCommandClass parent_class;
91
96
};
92
97
 
 
98
struct _FolksInspectCommandsBackendsRunData {
 
99
        int _state_;
 
100
        GObject* _source_object_;
 
101
        GAsyncResult* _res_;
 
102
        GSimpleAsyncResult* _async_result;
 
103
        FolksInspectCommandsBackends* self;
 
104
        gchar* command_string;
 
105
        const gchar* _tmp0_;
 
106
        FolksInspectClient* _tmp1_;
 
107
        FolksBackendStore* _tmp2_;
 
108
        FolksBackendStore* _tmp3_;
 
109
        GeeCollection* _tmp4_;
 
110
        GeeCollection* backends;
 
111
        GeeCollection* _tmp5_;
 
112
        gint _tmp6_;
 
113
        gint _tmp7_;
 
114
        GeeCollection* _tmp8_;
 
115
        GeeIterator* _tmp9_;
 
116
        GeeIterator* _backend_it;
 
117
        GeeIterator* _tmp10_;
 
118
        gboolean _tmp11_;
 
119
        GeeIterator* _tmp12_;
 
120
        gpointer _tmp13_;
 
121
        FolksBackend* backend;
 
122
        FolksBackend* _tmp14_;
 
123
        const gchar* _tmp15_;
 
124
        const gchar* _tmp16_;
 
125
        FolksInspectClient* _tmp17_;
 
126
        FolksBackendStore* _tmp18_;
 
127
        FolksBackendStore* _tmp19_;
 
128
        const gchar* _tmp20_;
 
129
        FolksBackend* _tmp21_;
 
130
        FolksBackend* _vala1_backend;
 
131
        FolksBackend* _tmp22_;
 
132
        const gchar* _tmp23_;
 
133
        FolksBackend* _tmp24_;
 
134
        const gchar* _tmp25_;
 
135
        const gchar* _tmp26_;
 
136
        FolksBackend* _tmp27_;
 
137
        GeeMap* _tmp28_;
 
138
        GeeMap* _tmp29_;
 
139
        gint _tmp30_;
 
140
        gint _tmp31_;
 
141
        FolksBackend* _tmp32_;
 
142
        GeeMap* _tmp33_;
 
143
        GeeMap* _tmp34_;
 
144
        GeeCollection* _tmp35_;
 
145
        GeeCollection* _tmp36_;
 
146
        GeeCollection* _tmp37_;
 
147
        GeeIterator* _tmp38_;
 
148
        GeeIterator* _tmp39_;
 
149
        GeeIterator* _store_it;
 
150
        GeeIterator* _tmp40_;
 
151
        gboolean _tmp41_;
 
152
        GeeIterator* _tmp42_;
 
153
        gpointer _tmp43_;
 
154
        FolksPersonaStore* store;
 
155
        FolksPersonaStore* _tmp44_;
 
156
        const gchar* _tmp45_;
 
157
        const gchar* _tmp46_;
 
158
        FolksPersonaStore* _tmp47_;
 
159
        const gchar* _tmp48_;
 
160
        const gchar* _tmp49_;
 
161
        FolksPersonaStore* _tmp50_;
 
162
        const gchar* _tmp51_;
 
163
        const gchar* _tmp52_;
 
164
};
 
165
 
93
166
 
94
167
static gpointer folks_inspect_commands_backends_parent_class = NULL;
95
168
 
108
181
FolksInspectCommandsBackends* folks_inspect_commands_backends_new (FolksInspectClient* client);
109
182
FolksInspectCommandsBackends* folks_inspect_commands_backends_construct (GType object_type, FolksInspectClient* client);
110
183
FolksInspectCommand* folks_inspect_command_construct (GType object_type, FolksInspectClient* client);
111
 
static void folks_inspect_commands_backends_real_run (FolksInspectCommand* base, const gchar* command_string);
 
184
static void folks_inspect_commands_backends_real_run_data_free (gpointer _data);
 
185
static void folks_inspect_commands_backends_real_run (FolksInspectCommand* base, const gchar* command_string, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
186
static gboolean folks_inspect_commands_backends_real_run_co (FolksInspectCommandsBackendsRunData* _data_);
112
187
FolksBackendStore* folks_inspect_client_get_backend_store (FolksInspectClient* self);
113
188
void folks_inspect_utils_print_line (const gchar* format, ...);
114
189
void folks_inspect_utils_indent (void);
135
210
}
136
211
 
137
212
 
138
 
static void folks_inspect_commands_backends_real_run (FolksInspectCommand* base, const gchar* command_string) {
 
213
static void folks_inspect_commands_backends_real_run_data_free (gpointer _data) {
 
214
        FolksInspectCommandsBackendsRunData* _data_;
 
215
        _data_ = _data;
 
216
        _g_free0 (_data_->command_string);
 
217
        _folks_inspect_command_unref0 (_data_->self);
 
218
        g_slice_free (FolksInspectCommandsBackendsRunData, _data_);
 
219
}
 
220
 
 
221
 
 
222
static gpointer _folks_inspect_command_ref0 (gpointer self) {
 
223
        return self ? folks_inspect_command_ref (self) : NULL;
 
224
}
 
225
 
 
226
 
 
227
static void folks_inspect_commands_backends_real_run (FolksInspectCommand* base, const gchar* command_string, GAsyncReadyCallback _callback_, gpointer _user_data_) {
139
228
        FolksInspectCommandsBackends * self;
140
 
        const gchar* _tmp0_;
 
229
        FolksInspectCommandsBackendsRunData* _data_;
 
230
        FolksInspectCommandsBackends* _tmp0_;
 
231
        const gchar* _tmp1_;
 
232
        gchar* _tmp2_;
141
233
        self = (FolksInspectCommandsBackends*) base;
142
 
        _tmp0_ = command_string;
143
 
        if (_tmp0_ == NULL) {
144
 
                FolksInspectClient* _tmp1_;
145
 
                FolksBackendStore* _tmp2_;
146
 
                FolksBackendStore* _tmp3_;
147
 
                GeeCollection* _tmp4_ = NULL;
148
 
                GeeCollection* backends;
149
 
                GeeCollection* _tmp5_;
150
 
                gint _tmp6_;
151
 
                gint _tmp7_;
152
 
                _tmp1_ = ((FolksInspectCommand*) self)->client;
153
 
                _tmp2_ = folks_inspect_client_get_backend_store (_tmp1_);
154
 
                _tmp3_ = _tmp2_;
155
 
                _tmp4_ = folks_backend_store_list_backends (_tmp3_);
156
 
                backends = _tmp4_;
157
 
                _tmp5_ = backends;
158
 
                _tmp6_ = gee_collection_get_size (_tmp5_);
159
 
                _tmp7_ = _tmp6_;
160
 
                folks_inspect_utils_print_line ("%u backends:", (guint) _tmp7_);
161
 
                folks_inspect_utils_indent ();
162
 
                {
163
 
                        GeeCollection* _tmp8_;
164
 
                        GeeIterator* _tmp9_ = NULL;
165
 
                        GeeIterator* _backend_it;
166
 
                        _tmp8_ = backends;
167
 
                        _tmp9_ = gee_iterable_iterator ((GeeIterable*) _tmp8_);
168
 
                        _backend_it = _tmp9_;
169
 
                        while (TRUE) {
170
 
                                GeeIterator* _tmp10_;
171
 
                                gboolean _tmp11_ = FALSE;
172
 
                                GeeIterator* _tmp12_;
173
 
                                gpointer _tmp13_ = NULL;
174
 
                                FolksBackend* backend;
175
 
                                FolksBackend* _tmp14_;
176
 
                                const gchar* _tmp15_;
177
 
                                const gchar* _tmp16_;
178
 
                                _tmp10_ = _backend_it;
179
 
                                _tmp11_ = gee_iterator_next (_tmp10_);
180
 
                                if (!_tmp11_) {
181
 
                                        break;
182
 
                                }
183
 
                                _tmp12_ = _backend_it;
184
 
                                _tmp13_ = gee_iterator_get (_tmp12_);
185
 
                                backend = (FolksBackend*) _tmp13_;
186
 
                                _tmp14_ = backend;
187
 
                                _tmp15_ = folks_backend_get_name (_tmp14_);
188
 
                                _tmp16_ = _tmp15_;
189
 
                                folks_inspect_utils_print_line ("%s", _tmp16_);
190
 
                                _g_object_unref0 (backend);
191
 
                        }
192
 
                        _g_object_unref0 (_backend_it);
193
 
                }
194
 
                folks_inspect_utils_unindent ();
195
 
                _g_object_unref0 (backends);
196
 
        } else {
197
 
                FolksInspectClient* _tmp17_;
198
 
                FolksBackendStore* _tmp18_;
199
 
                FolksBackendStore* _tmp19_;
200
 
                const gchar* _tmp20_;
201
 
                FolksBackend* _tmp21_ = NULL;
202
 
                FolksBackend* backend;
203
 
                FolksBackend* _tmp22_;
204
 
                FolksBackend* _tmp24_;
205
 
                const gchar* _tmp25_;
206
 
                const gchar* _tmp26_;
207
 
                FolksBackend* _tmp27_;
208
 
                GeeMap* _tmp28_;
209
 
                GeeMap* _tmp29_;
210
 
                gint _tmp30_;
211
 
                gint _tmp31_;
212
 
                _tmp17_ = ((FolksInspectCommand*) self)->client;
213
 
                _tmp18_ = folks_inspect_client_get_backend_store (_tmp17_);
214
 
                _tmp19_ = _tmp18_;
215
 
                _tmp20_ = command_string;
216
 
                _tmp21_ = folks_backend_store_dup_backend_by_name (_tmp19_, _tmp20_);
217
 
                backend = _tmp21_;
218
 
                _tmp22_ = backend;
219
 
                if (_tmp22_ == NULL) {
220
 
                        const gchar* _tmp23_;
221
 
                        _tmp23_ = command_string;
222
 
                        folks_inspect_utils_print_line ("Unrecognised backend name '%s'.", _tmp23_);
223
 
                        _g_object_unref0 (backend);
224
 
                        return;
225
 
                }
226
 
                _tmp24_ = backend;
227
 
                _tmp25_ = folks_backend_get_name (_tmp24_);
228
 
                _tmp26_ = _tmp25_;
229
 
                _tmp27_ = backend;
230
 
                _tmp28_ = folks_backend_get_persona_stores (_tmp27_);
231
 
                _tmp29_ = _tmp28_;
232
 
                _tmp30_ = gee_map_get_size (_tmp29_);
233
 
                _tmp31_ = _tmp30_;
234
 
                folks_inspect_utils_print_line ("Backend '%s' with %u persona stores " "(type ID, ID ('display name')):", _tmp26_, _tmp31_);
235
 
                folks_inspect_utils_indent ();
236
 
                {
237
 
                        FolksBackend* _tmp32_;
238
 
                        GeeMap* _tmp33_;
239
 
                        GeeMap* _tmp34_;
240
 
                        GeeCollection* _tmp35_;
241
 
                        GeeCollection* _tmp36_;
242
 
                        GeeCollection* _tmp37_;
243
 
                        GeeIterator* _tmp38_ = NULL;
244
 
                        GeeIterator* _tmp39_;
245
 
                        GeeIterator* _store_it;
246
 
                        _tmp32_ = backend;
247
 
                        _tmp33_ = folks_backend_get_persona_stores (_tmp32_);
248
 
                        _tmp34_ = _tmp33_;
249
 
                        _tmp35_ = gee_map_get_values (_tmp34_);
250
 
                        _tmp36_ = _tmp35_;
251
 
                        _tmp37_ = _tmp36_;
252
 
                        _tmp38_ = gee_iterable_iterator ((GeeIterable*) _tmp37_);
253
 
                        _tmp39_ = _tmp38_;
254
 
                        _g_object_unref0 (_tmp37_);
255
 
                        _store_it = _tmp39_;
256
 
                        while (TRUE) {
257
 
                                GeeIterator* _tmp40_;
258
 
                                gboolean _tmp41_ = FALSE;
259
 
                                GeeIterator* _tmp42_;
260
 
                                gpointer _tmp43_ = NULL;
261
 
                                FolksPersonaStore* store;
262
 
                                FolksPersonaStore* _tmp44_;
263
 
                                const gchar* _tmp45_;
264
 
                                const gchar* _tmp46_;
265
 
                                FolksPersonaStore* _tmp47_;
266
 
                                const gchar* _tmp48_;
267
 
                                const gchar* _tmp49_;
268
 
                                FolksPersonaStore* _tmp50_;
269
 
                                const gchar* _tmp51_;
270
 
                                const gchar* _tmp52_;
271
 
                                _tmp40_ = _store_it;
272
 
                                _tmp41_ = gee_iterator_next (_tmp40_);
273
 
                                if (!_tmp41_) {
274
 
                                        break;
275
 
                                }
276
 
                                _tmp42_ = _store_it;
277
 
                                _tmp43_ = gee_iterator_get (_tmp42_);
278
 
                                store = (FolksPersonaStore*) _tmp43_;
279
 
                                _tmp44_ = store;
280
 
                                _tmp45_ = folks_persona_store_get_type_id (_tmp44_);
281
 
                                _tmp46_ = _tmp45_;
282
 
                                _tmp47_ = store;
283
 
                                _tmp48_ = folks_persona_store_get_id (_tmp47_);
284
 
                                _tmp49_ = _tmp48_;
285
 
                                _tmp50_ = store;
286
 
                                _tmp51_ = folks_persona_store_get_display_name (_tmp50_);
287
 
                                _tmp52_ = _tmp51_;
288
 
                                folks_inspect_utils_print_line ("%s, %s ('%s')", _tmp46_, _tmp49_, _tmp52_);
289
 
                                _g_object_unref0 (store);
290
 
                        }
291
 
                        _g_object_unref0 (_store_it);
292
 
                }
293
 
                folks_inspect_utils_unindent ();
294
 
                _g_object_unref0 (backend);
295
 
        }
 
234
        _data_ = g_slice_new0 (FolksInspectCommandsBackendsRunData);
 
235
        _data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, folks_inspect_commands_backends_real_run);
 
236
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, folks_inspect_commands_backends_real_run_data_free);
 
237
        _tmp0_ = _folks_inspect_command_ref0 (self);
 
238
        _data_->self = _tmp0_;
 
239
        _tmp1_ = command_string;
 
240
        _tmp2_ = g_strdup (_tmp1_);
 
241
        _g_free0 (_data_->command_string);
 
242
        _data_->command_string = _tmp2_;
 
243
        folks_inspect_commands_backends_real_run_co (_data_);
 
244
}
 
245
 
 
246
 
 
247
static void folks_inspect_commands_backends_real_run_finish (FolksInspectCommand* base, GAsyncResult* _res_) {
 
248
        FolksInspectCommandsBackendsRunData* _data_;
 
249
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
250
}
 
251
 
 
252
 
 
253
static gboolean folks_inspect_commands_backends_real_run_co (FolksInspectCommandsBackendsRunData* _data_) {
 
254
        switch (_data_->_state_) {
 
255
                case 0:
 
256
                goto _state_0;
 
257
                default:
 
258
                g_assert_not_reached ();
 
259
        }
 
260
        _state_0:
 
261
        _data_->_tmp0_ = _data_->command_string;
 
262
        if (_data_->_tmp0_ == NULL) {
 
263
                _data_->_tmp1_ = ((FolksInspectCommand*) _data_->self)->client;
 
264
                _data_->_tmp2_ = folks_inspect_client_get_backend_store (_data_->_tmp1_);
 
265
                _data_->_tmp3_ = _data_->_tmp2_;
 
266
                _data_->_tmp4_ = NULL;
 
267
                _data_->_tmp4_ = folks_backend_store_list_backends (_data_->_tmp3_);
 
268
                _data_->backends = _data_->_tmp4_;
 
269
                _data_->_tmp5_ = _data_->backends;
 
270
                _data_->_tmp6_ = gee_collection_get_size (_data_->_tmp5_);
 
271
                _data_->_tmp7_ = _data_->_tmp6_;
 
272
                folks_inspect_utils_print_line ("%u backends:", (guint) _data_->_tmp7_);
 
273
                folks_inspect_utils_indent ();
 
274
                {
 
275
                        _data_->_tmp8_ = _data_->backends;
 
276
                        _data_->_tmp9_ = NULL;
 
277
                        _data_->_tmp9_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp8_);
 
278
                        _data_->_backend_it = _data_->_tmp9_;
 
279
                        while (TRUE) {
 
280
                                _data_->_tmp10_ = _data_->_backend_it;
 
281
                                _data_->_tmp11_ = FALSE;
 
282
                                _data_->_tmp11_ = gee_iterator_next (_data_->_tmp10_);
 
283
                                if (!_data_->_tmp11_) {
 
284
                                        break;
 
285
                                }
 
286
                                _data_->_tmp12_ = _data_->_backend_it;
 
287
                                _data_->_tmp13_ = NULL;
 
288
                                _data_->_tmp13_ = gee_iterator_get (_data_->_tmp12_);
 
289
                                _data_->backend = (FolksBackend*) _data_->_tmp13_;
 
290
                                _data_->_tmp14_ = _data_->backend;
 
291
                                _data_->_tmp15_ = folks_backend_get_name (_data_->_tmp14_);
 
292
                                _data_->_tmp16_ = _data_->_tmp15_;
 
293
                                folks_inspect_utils_print_line ("%s", _data_->_tmp16_);
 
294
                                _g_object_unref0 (_data_->backend);
 
295
                        }
 
296
                        _g_object_unref0 (_data_->_backend_it);
 
297
                }
 
298
                folks_inspect_utils_unindent ();
 
299
                _g_object_unref0 (_data_->backends);
 
300
        } else {
 
301
                _data_->_tmp17_ = ((FolksInspectCommand*) _data_->self)->client;
 
302
                _data_->_tmp18_ = folks_inspect_client_get_backend_store (_data_->_tmp17_);
 
303
                _data_->_tmp19_ = _data_->_tmp18_;
 
304
                _data_->_tmp20_ = _data_->command_string;
 
305
                _data_->_tmp21_ = NULL;
 
306
                _data_->_tmp21_ = folks_backend_store_dup_backend_by_name (_data_->_tmp19_, _data_->_tmp20_);
 
307
                _data_->_vala1_backend = _data_->_tmp21_;
 
308
                _data_->_tmp22_ = _data_->_vala1_backend;
 
309
                if (_data_->_tmp22_ == NULL) {
 
310
                        _data_->_tmp23_ = _data_->command_string;
 
311
                        folks_inspect_utils_print_line ("Unrecognised backend name '%s'.", _data_->_tmp23_);
 
312
                        _g_object_unref0 (_data_->_vala1_backend);
 
313
                        if (_data_->_state_ == 0) {
 
314
                                g_simple_async_result_complete_in_idle (_data_->_async_result);
 
315
                        } else {
 
316
                                g_simple_async_result_complete (_data_->_async_result);
 
317
                        }
 
318
                        g_object_unref (_data_->_async_result);
 
319
                        return FALSE;
 
320
                }
 
321
                _data_->_tmp24_ = _data_->_vala1_backend;
 
322
                _data_->_tmp25_ = folks_backend_get_name (_data_->_tmp24_);
 
323
                _data_->_tmp26_ = _data_->_tmp25_;
 
324
                _data_->_tmp27_ = _data_->_vala1_backend;
 
325
                _data_->_tmp28_ = folks_backend_get_persona_stores (_data_->_tmp27_);
 
326
                _data_->_tmp29_ = _data_->_tmp28_;
 
327
                _data_->_tmp30_ = gee_map_get_size (_data_->_tmp29_);
 
328
                _data_->_tmp31_ = _data_->_tmp30_;
 
329
                folks_inspect_utils_print_line ("Backend '%s' with %u persona stores " "(type ID, ID ('display name')):", _data_->_tmp26_, _data_->_tmp31_);
 
330
                folks_inspect_utils_indent ();
 
331
                {
 
332
                        _data_->_tmp32_ = _data_->_vala1_backend;
 
333
                        _data_->_tmp33_ = folks_backend_get_persona_stores (_data_->_tmp32_);
 
334
                        _data_->_tmp34_ = _data_->_tmp33_;
 
335
                        _data_->_tmp35_ = gee_map_get_values (_data_->_tmp34_);
 
336
                        _data_->_tmp36_ = _data_->_tmp35_;
 
337
                        _data_->_tmp37_ = _data_->_tmp36_;
 
338
                        _data_->_tmp38_ = NULL;
 
339
                        _data_->_tmp38_ = gee_iterable_iterator ((GeeIterable*) _data_->_tmp37_);
 
340
                        _data_->_tmp39_ = _data_->_tmp38_;
 
341
                        _g_object_unref0 (_data_->_tmp37_);
 
342
                        _data_->_store_it = _data_->_tmp39_;
 
343
                        while (TRUE) {
 
344
                                _data_->_tmp40_ = _data_->_store_it;
 
345
                                _data_->_tmp41_ = FALSE;
 
346
                                _data_->_tmp41_ = gee_iterator_next (_data_->_tmp40_);
 
347
                                if (!_data_->_tmp41_) {
 
348
                                        break;
 
349
                                }
 
350
                                _data_->_tmp42_ = _data_->_store_it;
 
351
                                _data_->_tmp43_ = NULL;
 
352
                                _data_->_tmp43_ = gee_iterator_get (_data_->_tmp42_);
 
353
                                _data_->store = (FolksPersonaStore*) _data_->_tmp43_;
 
354
                                _data_->_tmp44_ = _data_->store;
 
355
                                _data_->_tmp45_ = folks_persona_store_get_type_id (_data_->_tmp44_);
 
356
                                _data_->_tmp46_ = _data_->_tmp45_;
 
357
                                _data_->_tmp47_ = _data_->store;
 
358
                                _data_->_tmp48_ = folks_persona_store_get_id (_data_->_tmp47_);
 
359
                                _data_->_tmp49_ = _data_->_tmp48_;
 
360
                                _data_->_tmp50_ = _data_->store;
 
361
                                _data_->_tmp51_ = folks_persona_store_get_display_name (_data_->_tmp50_);
 
362
                                _data_->_tmp52_ = _data_->_tmp51_;
 
363
                                folks_inspect_utils_print_line ("%s, %s ('%s')", _data_->_tmp46_, _data_->_tmp49_, _data_->_tmp52_);
 
364
                                _g_object_unref0 (_data_->store);
 
365
                        }
 
366
                        _g_object_unref0 (_data_->_store_it);
 
367
                }
 
368
                folks_inspect_utils_unindent ();
 
369
                _g_object_unref0 (_data_->_vala1_backend);
 
370
        }
 
371
        if (_data_->_state_ == 0) {
 
372
                g_simple_async_result_complete_in_idle (_data_->_async_result);
 
373
        } else {
 
374
                g_simple_async_result_complete (_data_->_async_result);
 
375
        }
 
376
        g_object_unref (_data_->_async_result);
 
377
        return FALSE;
296
378
}
297
379
 
298
380
 
372
454
static void folks_inspect_commands_backends_class_init (FolksInspectCommandsBackendsClass * klass) {
373
455
        folks_inspect_commands_backends_parent_class = g_type_class_peek_parent (klass);
374
456
        FOLKS_INSPECT_COMMAND_CLASS (klass)->run = folks_inspect_commands_backends_real_run;
 
457
        FOLKS_INSPECT_COMMAND_CLASS (klass)->run_finish = folks_inspect_commands_backends_real_run_finish;
375
458
        FOLKS_INSPECT_COMMAND_CLASS (klass)->complete_subcommand = folks_inspect_commands_backends_real_complete_subcommand;
376
459
        FOLKS_INSPECT_COMMAND_CLASS (klass)->get_name = folks_inspect_commands_backends_real_get_name;
377
460
        FOLKS_INSPECT_COMMAND_CLASS (klass)->get_description = folks_inspect_commands_backends_real_get_description;