← Back to branch summary

~ubuntu-branches/debian/wheezy/betaradio/wheezy

« back to all changes in this revision

Viewing changes to src/json_soup.c

  • Committer: Package Import Robot
  • Author(s): Shih-Yuan Lee (FourDollars)
  • Date: 2012-01-14 20:58:32 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20120114205832-j58rskmjowwgcv37
Tags: 1.4-1
* New upstream release.
* debian/patches/00_dont_install_header: Don't install header file into the
  system.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/json_soup.c
1
 
/* json_soup.c generated by valac 0.12.0, the Vala compiler
 
1
/* json_soup.c generated by valac 0.14.0, the Vala compiler
2
2
 * generated from json_soup.vala, do not modify */
3
3
 
4
4
/* -*- coding: utf-8; indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- */
26
26
typedef struct _JsonSoupPrivate JsonSoupPrivate;
27
27
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
28
28
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
29
 
#define _soup_uri_free0(var) ((var == NULL) ? NULL : (var = (soup_uri_free (var), NULL)))
30
 
#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
31
 
#define _json_array_unref0(var) ((var == NULL) ? NULL : (var = (json_array_unref (var), NULL)))
 
29
#define __vala_SoupURI_free0(var) ((var == NULL) ? NULL : (var = (_vala_SoupURI_free (var), NULL)))
 
30
#define __vala_JsonObject_free0(var) ((var == NULL) ? NULL : (var = (_vala_JsonObject_free (var), NULL)))
 
31
#define __vala_JsonArray_free0(var) ((var == NULL) ? NULL : (var = (_vala_JsonArray_free (var), NULL)))
32
32
 
33
33
struct _JsonSoup {
34
34
        GObject parent_instance;
58
58
JsonSoup* json_soup_construct_file (GType object_type, const gchar* file);
59
59
JsonSoup* json_soup_new_http (const gchar* url);
60
60
JsonSoup* json_soup_construct_http (GType object_type, const gchar* url);
 
61
static void _vala_SoupURI_free (SoupURI* self);
61
62
JsonSoup* json_soup_object (JsonSoup* self, const gchar* name);
 
63
static JsonObject* _vala_JsonObject_copy (JsonObject* self);
 
64
static void _vala_JsonObject_free (JsonObject* self);
62
65
JsonSoup* json_soup_sibling (JsonSoup* self, const gchar* name);
63
66
JsonSoup* json_soup_parent (JsonSoup* self);
64
67
JsonSoup* json_soup_array (JsonSoup* self, gint idx);
 
68
static JsonArray* _vala_JsonArray_copy (JsonArray* self);
 
69
static void _vala_JsonArray_free (JsonArray* self);
65
70
JsonSoup* json_soup_grandparent (JsonSoup* self);
66
71
JsonSoup* json_soup_reset (JsonSoup* self);
67
72
static gboolean json_soup_is_value (JsonSoup* self);
83
88
 
84
89
JsonSoup* json_soup_construct_buffer (GType object_type, const gchar* buffer) {
85
90
        JsonSoup * self = NULL;
86
 
        JsonParser* _tmp0_ = NULL;
87
 
        JsonNode* _tmp1_ = NULL;
 
91
        JsonParser* _tmp0_;
88
92
        GError * _inner_error_ = NULL;
89
93
        g_return_val_if_fail (buffer != NULL, NULL);
90
94
        self = (JsonSoup*) g_object_new (object_type, NULL);
91
95
        _tmp0_ = json_parser_new ();
92
96
        _g_object_unref0 (self->priv->parser);
93
97
        self->priv->parser = _tmp0_;
94
 
        json_parser_load_from_data (self->priv->parser, buffer, (gssize) (-1), &_inner_error_);
95
 
        if (_inner_error_ != NULL) {
96
 
                goto __catch1_g_error;
 
98
        {
 
99
                JsonParser* _tmp1_;
 
100
                const gchar* _tmp2_;
 
101
                JsonParser* _tmp3_;
 
102
                JsonNode* _tmp4_ = NULL;
 
103
                _tmp1_ = self->priv->parser;
 
104
                _tmp2_ = buffer;
 
105
                json_parser_load_from_data (_tmp1_, _tmp2_, (gssize) (-1), &_inner_error_);
 
106
                if (_inner_error_ != NULL) {
 
107
                        goto __catch2_g_error;
 
108
                }
 
109
                _tmp3_ = self->priv->parser;
 
110
                _tmp4_ = json_parser_get_root (_tmp3_);
 
111
                self->priv->node = _tmp4_;
97
112
        }
98
 
        _tmp1_ = json_parser_get_root (self->priv->parser);
99
 
        self->priv->node = _tmp1_;
100
 
        goto __finally1;
101
 
        __catch1_g_error:
 
113
        goto __finally2;
 
114
        __catch2_g_error:
102
115
        {
103
 
                GError * e;
 
116
                GError* e = NULL;
 
117
                GError* _tmp5_;
 
118
                const gchar* _tmp6_;
104
119
                e = _inner_error_;
105
120
                _inner_error_ = NULL;
106
 
                g_warning ("json_soup.vala:34: %s", e->message);
 
121
                _tmp5_ = e;
 
122
                _tmp6_ = _tmp5_->message;
 
123
                g_warning ("json_soup.vala:34: %s", _tmp6_);
107
124
                _g_error_free0 (e);
108
125
        }
109
 
        __finally1:
 
126
        __finally2:
110
127
        if (_inner_error_ != NULL) {
111
128
                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);
112
129
                g_clear_error (&_inner_error_);
123
140
 
124
141
JsonSoup* json_soup_construct_file (GType object_type, const gchar* file) {
125
142
        JsonSoup * self = NULL;
126
 
        JsonParser* _tmp0_ = NULL;
127
 
        JsonNode* _tmp1_ = NULL;
 
143
        JsonParser* _tmp0_;
128
144
        GError * _inner_error_ = NULL;
129
145
        g_return_val_if_fail (file != NULL, NULL);
130
146
        self = (JsonSoup*) g_object_new (object_type, NULL);
131
147
        _tmp0_ = json_parser_new ();
132
148
        _g_object_unref0 (self->priv->parser);
133
149
        self->priv->parser = _tmp0_;
134
 
        json_parser_load_from_file (self->priv->parser, file, &_inner_error_);
135
 
        if (_inner_error_ != NULL) {
136
 
                goto __catch2_g_error;
 
150
        {
 
151
                JsonParser* _tmp1_;
 
152
                const gchar* _tmp2_;
 
153
                JsonParser* _tmp3_;
 
154
                JsonNode* _tmp4_ = NULL;
 
155
                _tmp1_ = self->priv->parser;
 
156
                _tmp2_ = file;
 
157
                json_parser_load_from_file (_tmp1_, _tmp2_, &_inner_error_);
 
158
                if (_inner_error_ != NULL) {
 
159
                        goto __catch3_g_error;
 
160
                }
 
161
                _tmp3_ = self->priv->parser;
 
162
                _tmp4_ = json_parser_get_root (_tmp3_);
 
163
                self->priv->node = _tmp4_;
137
164
        }
138
 
        _tmp1_ = json_parser_get_root (self->priv->parser);
139
 
        self->priv->node = _tmp1_;
140
 
        goto __finally2;
141
 
        __catch2_g_error:
 
165
        goto __finally3;
 
166
        __catch3_g_error:
142
167
        {
143
 
                GError * e;
 
168
                GError* e = NULL;
 
169
                GError* _tmp5_;
 
170
                const gchar* _tmp6_;
144
171
                e = _inner_error_;
145
172
                _inner_error_ = NULL;
146
 
                g_warning ("json_soup.vala:43: %s", e->message);
 
173
                _tmp5_ = e;
 
174
                _tmp6_ = _tmp5_->message;
 
175
                g_warning ("json_soup.vala:43: %s", _tmp6_);
147
176
                _g_error_free0 (e);
148
177
        }
149
 
        __finally2:
 
178
        __finally3:
150
179
        if (_inner_error_ != NULL) {
151
180
                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);
152
181
                g_clear_error (&_inner_error_);
161
190
}
162
191
 
163
192
 
 
193
static void _vala_SoupURI_free (SoupURI* self) {
 
194
        g_boxed_free (soup_uri_get_type (), self);
 
195
}
 
196
 
 
197
 
164
198
JsonSoup* json_soup_construct_http (GType object_type, const gchar* url) {
165
199
        JsonSoup * self = NULL;
166
 
        SoupSessionAsync* _tmp0_ = NULL;
167
 
        SoupSessionAsync* session;
168
 
        SoupURI* _tmp1_ = NULL;
 
200
        SoupSessionSync* _tmp0_;
 
201
        SoupSessionSync* session;
 
202
        const gchar* _tmp1_;
169
203
        SoupURI* _tmp2_;
170
 
        SoupMessage* _tmp3_ = NULL;
 
204
        SoupURI* _tmp3_;
171
205
        SoupMessage* _tmp4_;
 
206
        SoupMessage* _tmp5_;
172
207
        SoupMessage* message;
173
 
        guint _tmp5_;
174
 
        JsonParser* _tmp6_ = NULL;
175
 
        JsonNode* _tmp7_ = NULL;
 
208
        SoupSessionSync* _tmp6_;
 
209
        SoupMessage* _tmp7_;
 
210
        guint _tmp8_ = 0U;
 
211
        JsonParser* _tmp10_;
176
212
        GError * _inner_error_ = NULL;
177
213
        g_return_val_if_fail (url != NULL, NULL);
178
214
        self = (JsonSoup*) g_object_new (object_type, NULL);
179
 
        _tmp0_ = (SoupSessionAsync*) soup_session_async_new ();
 
215
        _tmp0_ = (SoupSessionSync*) soup_session_sync_new ();
180
216
        session = _tmp0_;
181
 
        _tmp1_ = soup_uri_new (url);
182
 
        _tmp2_ = _tmp1_;
183
 
        _tmp3_ = soup_message_new_from_uri ("GET", _tmp2_);
184
 
        _tmp4_ = _tmp3_;
185
 
        _soup_uri_free0 (_tmp2_);
186
 
        message = _tmp4_;
187
 
        _tmp5_ = soup_session_send_message ((SoupSession*) session, message);
188
 
        if (_tmp5_ != 200) {
189
 
                g_warning ("json_soup.vala:50: Can not connect to %s", url);
 
217
        _tmp1_ = url;
 
218
        _tmp2_ = soup_uri_new (_tmp1_);
 
219
        _tmp3_ = _tmp2_;
 
220
        _tmp4_ = soup_message_new_from_uri ("GET", _tmp3_);
 
221
        _tmp5_ = _tmp4_;
 
222
        __vala_SoupURI_free0 (_tmp3_);
 
223
        message = _tmp5_;
 
224
        _tmp6_ = session;
 
225
        _tmp7_ = message;
 
226
        _tmp8_ = soup_session_send_message ((SoupSession*) _tmp6_, _tmp7_);
 
227
        if (_tmp8_ != ((guint) 200)) {
 
228
                const gchar* _tmp9_;
 
229
                _tmp9_ = url;
 
230
                g_warning ("json_soup.vala:50: Can not connect to %s", _tmp9_);
190
231
        }
191
 
        _tmp6_ = json_parser_new ();
 
232
        _tmp10_ = json_parser_new ();
192
233
        _g_object_unref0 (self->priv->parser);
193
 
        self->priv->parser = _tmp6_;
194
 
        json_parser_load_from_data (self->priv->parser, (const gchar*) message->response_body->data, (gssize) (-1), &_inner_error_);
195
 
        if (_inner_error_ != NULL) {
196
 
                goto __catch3_g_error;
 
234
        self->priv->parser = _tmp10_;
 
235
        {
 
236
                JsonParser* _tmp11_;
 
237
                SoupMessage* _tmp12_;
 
238
                SoupMessageBody* _tmp13_;
 
239
                guint8* _tmp14_;
 
240
                gint _tmp14__length1;
 
241
                JsonParser* _tmp15_;
 
242
                JsonNode* _tmp16_ = NULL;
 
243
                _tmp11_ = self->priv->parser;
 
244
                _tmp12_ = message;
 
245
                _tmp13_ = _tmp12_->response_body;
 
246
                _tmp14_ = _tmp13_->data;
 
247
                _tmp14__length1 = (gint) _tmp13_->length;
 
248
                json_parser_load_from_data (_tmp11_, (const gchar*) _tmp14_, (gssize) (-1), &_inner_error_);
 
249
                if (_inner_error_ != NULL) {
 
250
                        goto __catch4_g_error;
 
251
                }
 
252
                _tmp15_ = self->priv->parser;
 
253
                _tmp16_ = json_parser_get_root (_tmp15_);
 
254
                self->priv->node = _tmp16_;
197
255
        }
198
 
        _tmp7_ = json_parser_get_root (self->priv->parser);
199
 
        self->priv->node = _tmp7_;
200
 
        goto __finally3;
201
 
        __catch3_g_error:
 
256
        goto __finally4;
 
257
        __catch4_g_error:
202
258
        {
203
 
                GError * e;
 
259
                GError* e = NULL;
 
260
                GError* _tmp17_;
 
261
                const gchar* _tmp18_;
204
262
                e = _inner_error_;
205
263
                _inner_error_ = NULL;
206
 
                g_warning ("json_soup.vala:57: %s", e->message);
 
264
                _tmp17_ = e;
 
265
                _tmp18_ = _tmp17_->message;
 
266
                g_warning ("json_soup.vala:57: %s", _tmp18_);
207
267
                _g_error_free0 (e);
208
268
        }
209
 
        __finally3:
 
269
        __finally4:
210
270
        if (_inner_error_ != NULL) {
211
271
                _g_object_unref0 (message);
212
272
                _g_object_unref0 (session);
225
285
}
226
286
 
227
287
 
228
 
static gpointer _json_object_ref0 (gpointer self) {
229
 
        return self ? json_object_ref (self) : NULL;
 
288
static JsonObject* _vala_JsonObject_copy (JsonObject* self) {
 
289
        return g_boxed_copy (json_object_get_type (), self);
 
290
}
 
291
 
 
292
 
 
293
static gpointer __vala_JsonObject_copy0 (gpointer self) {
 
294
        return self ? _vala_JsonObject_copy (self) : NULL;
 
295
}
 
296
 
 
297
 
 
298
static void _vala_JsonObject_free (JsonObject* self) {
 
299
        g_boxed_free (json_object_get_type (), self);
230
300
}
231
301
 
232
302
 
233
303
JsonSoup* json_soup_object (JsonSoup* self, const gchar* name) {
234
304
        JsonSoup* result = NULL;
235
 
        JsonNodeType _tmp0_;
236
 
        JsonObject* _tmp1_ = NULL;
237
 
        JsonObject* _tmp2_;
 
305
        JsonNode* _tmp0_;
 
306
        JsonNodeType _tmp1_ = 0;
 
307
        JsonNode* _tmp2_;
 
308
        JsonObject* _tmp3_ = NULL;
 
309
        JsonObject* _tmp4_;
238
310
        JsonObject* object;
239
 
        gboolean _tmp3_;
240
 
        JsonNode* _tmp4_ = NULL;
 
311
        JsonObject* _tmp5_;
 
312
        const gchar* _tmp6_;
 
313
        gboolean _tmp7_ = FALSE;
 
314
        JsonObject* _tmp9_;
 
315
        const gchar* _tmp10_;
 
316
        JsonNode* _tmp11_ = NULL;
241
317
        g_return_val_if_fail (self != NULL, NULL);
242
318
        g_return_val_if_fail (name != NULL, NULL);
243
 
        _tmp0_ = json_node_get_node_type (self->priv->node);
244
 
        if (_tmp0_ != JSON_NODE_OBJECT) {
 
319
        _tmp0_ = self->priv->node;
 
320
        _tmp1_ = json_node_get_node_type (_tmp0_);
 
321
        if (_tmp1_ != JSON_NODE_OBJECT) {
245
322
                g_warning ("json_soup.vala:70: This is not a object.");
246
323
                result = self;
247
324
                return result;
248
325
        }
249
 
        _tmp1_ = json_node_get_object (self->priv->node);
250
 
        _tmp2_ = _json_object_ref0 (_tmp1_);
251
 
        object = _tmp2_;
252
 
        _tmp3_ = json_object_has_member (object, name);
253
 
        if (_tmp3_ == FALSE) {
254
 
                g_warning ("json_soup.vala:75: There is no such member as %s.", name);
 
326
        _tmp2_ = self->priv->node;
 
327
        _tmp3_ = json_node_get_object (_tmp2_);
 
328
        _tmp4_ = __vala_JsonObject_copy0 (_tmp3_);
 
329
        object = _tmp4_;
 
330
        _tmp5_ = object;
 
331
        _tmp6_ = name;
 
332
        _tmp7_ = json_object_has_member (_tmp5_, _tmp6_);
 
333
        if (_tmp7_ == FALSE) {
 
334
                const gchar* _tmp8_;
 
335
                _tmp8_ = name;
 
336
                g_warning ("json_soup.vala:75: There is no such member as %s.", _tmp8_);
255
337
                result = self;
256
 
                _json_object_unref0 (object);
 
338
                __vala_JsonObject_free0 (object);
257
339
                return result;
258
340
        }
259
 
        _tmp4_ = json_object_get_member (object, name);
260
 
        self->priv->node = _tmp4_;
 
341
        _tmp9_ = object;
 
342
        _tmp10_ = name;
 
343
        _tmp11_ = json_object_get_member (_tmp9_, _tmp10_);
 
344
        self->priv->node = _tmp11_;
261
345
        result = self;
262
 
        _json_object_unref0 (object);
 
346
        __vala_JsonObject_free0 (object);
263
347
        return result;
264
348
}
265
349
 
266
350
 
267
351
JsonSoup* json_soup_sibling (JsonSoup* self, const gchar* name) {
268
352
        JsonSoup* result = NULL;
 
353
        const gchar* _tmp0_;
269
354
        g_return_val_if_fail (self != NULL, NULL);
270
355
        g_return_val_if_fail (name != NULL, NULL);
271
356
        json_soup_parent (self);
272
 
        json_soup_object (self, name);
 
357
        _tmp0_ = name;
 
358
        json_soup_object (self, _tmp0_);
273
359
        result = self;
274
360
        return result;
275
361
}
276
362
 
277
363
 
278
 
static gpointer _json_array_ref0 (gpointer self) {
279
 
        return self ? json_array_ref (self) : NULL;
 
364
static JsonArray* _vala_JsonArray_copy (JsonArray* self) {
 
365
        return g_boxed_copy (json_array_get_type (), self);
 
366
}
 
367
 
 
368
 
 
369
static gpointer __vala_JsonArray_copy0 (gpointer self) {
 
370
        return self ? _vala_JsonArray_copy (self) : NULL;
 
371
}
 
372
 
 
373
 
 
374
static void _vala_JsonArray_free (JsonArray* self) {
 
375
        g_boxed_free (json_array_get_type (), self);
280
376
}
281
377
 
282
378
 
283
379
JsonSoup* json_soup_array (JsonSoup* self, gint idx) {
284
380
        JsonSoup* result = NULL;
285
 
        JsonNodeType _tmp0_;
286
 
        JsonArray* _tmp1_ = NULL;
287
 
        JsonArray* _tmp2_;
 
381
        JsonNode* _tmp0_;
 
382
        JsonNodeType _tmp1_ = 0;
 
383
        JsonNode* _tmp2_;
 
384
        JsonArray* _tmp3_ = NULL;
 
385
        JsonArray* _tmp4_;
288
386
        JsonArray* array;
289
 
        guint _tmp3_;
 
387
        JsonArray* _tmp5_;
 
388
        guint _tmp6_ = 0U;
290
389
        gint length;
291
 
        gboolean _tmp4_ = FALSE;
292
 
        JsonNode* _tmp5_ = NULL;
 
390
        gboolean _tmp7_ = FALSE;
 
391
        gint _tmp8_;
 
392
        gint _tmp9_;
 
393
        gboolean _tmp11_;
 
394
        JsonArray* _tmp13_;
 
395
        gint _tmp14_;
 
396
        JsonNode* _tmp15_ = NULL;
293
397
        g_return_val_if_fail (self != NULL, NULL);
294
 
        _tmp0_ = json_node_get_node_type (self->priv->node);
295
 
        if (_tmp0_ != JSON_NODE_ARRAY) {
 
398
        _tmp0_ = self->priv->node;
 
399
        _tmp1_ = json_node_get_node_type (_tmp0_);
 
400
        if (_tmp1_ != JSON_NODE_ARRAY) {
296
401
                g_warning ("json_soup.vala:88: This is not a array.");
297
402
                result = self;
298
403
                return result;
299
404
        }
300
 
        _tmp1_ = json_node_get_array (self->priv->node);
301
 
        _tmp2_ = _json_array_ref0 (_tmp1_);
302
 
        array = _tmp2_;
303
 
        _tmp3_ = json_array_get_length (array);
304
 
        length = (gint) _tmp3_;
305
 
        if (idx > length) {
306
 
                _tmp4_ = TRUE;
 
405
        _tmp2_ = self->priv->node;
 
406
        _tmp3_ = json_node_get_array (_tmp2_);
 
407
        _tmp4_ = __vala_JsonArray_copy0 (_tmp3_);
 
408
        array = _tmp4_;
 
409
        _tmp5_ = array;
 
410
        _tmp6_ = json_array_get_length (_tmp5_);
 
411
        length = (gint) _tmp6_;
 
412
        _tmp8_ = idx;
 
413
        _tmp9_ = length;
 
414
        if (_tmp8_ > _tmp9_) {
 
415
                _tmp7_ = TRUE;
307
416
        } else {
308
 
                _tmp4_ = idx < 0;
 
417
                gint _tmp10_;
 
418
                _tmp10_ = idx;
 
419
                _tmp7_ = _tmp10_ < 0;
309
420
        }
310
 
        if (_tmp4_) {
311
 
                g_warning ("json_soup.vala:94: Out of index. %d", idx);
 
421
        _tmp11_ = _tmp7_;
 
422
        if (_tmp11_) {
 
423
                gint _tmp12_;
 
424
                _tmp12_ = idx;
 
425
                g_warning ("json_soup.vala:94: Out of index. %d", _tmp12_);
312
426
                result = self;
313
 
                _json_array_unref0 (array);
 
427
                __vala_JsonArray_free0 (array);
314
428
                return result;
315
429
        }
316
 
        _tmp5_ = json_array_get_element (array, (guint) idx);
317
 
        self->priv->node = _tmp5_;
 
430
        _tmp13_ = array;
 
431
        _tmp14_ = idx;
 
432
        _tmp15_ = json_array_get_element (_tmp13_, (guint) _tmp14_);
 
433
        self->priv->node = _tmp15_;
318
434
        result = self;
319
 
        _json_array_unref0 (array);
 
435
        __vala_JsonArray_free0 (array);
320
436
        return result;
321
437
}
322
438
 
323
439
 
324
440
JsonSoup* json_soup_parent (JsonSoup* self) {
325
441
        JsonSoup* result = NULL;
326
 
        JsonNode* _tmp0_ = NULL;
 
442
        JsonNode* _tmp0_;
 
443
        JsonNode* _tmp1_ = NULL;
327
444
        JsonNode* parent_node;
 
445
        JsonNode* _tmp2_;
 
446
        JsonNode* _tmp3_;
328
447
        g_return_val_if_fail (self != NULL, NULL);
329
 
        _tmp0_ = json_node_get_parent (self->priv->node);
330
 
        parent_node = _tmp0_;
331
 
        if (parent_node == NULL) {
 
448
        _tmp0_ = self->priv->node;
 
449
        _tmp1_ = json_node_get_parent (_tmp0_);
 
450
        parent_node = _tmp1_;
 
451
        _tmp2_ = parent_node;
 
452
        if (_tmp2_ == NULL) {
332
453
                g_warning ("json_soup.vala:103: Already be root.");
333
454
                result = self;
334
455
                return result;
335
456
        }
336
 
        self->priv->node = parent_node;
 
457
        _tmp3_ = parent_node;
 
458
        self->priv->node = _tmp3_;
337
459
        result = self;
338
460
        return result;
339
461
}
351
473
 
352
474
JsonSoup* json_soup_reset (JsonSoup* self) {
353
475
        JsonSoup* result = NULL;
354
 
        JsonNode* _tmp0_ = NULL;
 
476
        JsonParser* _tmp0_;
 
477
        JsonNode* _tmp1_ = NULL;
355
478
        g_return_val_if_fail (self != NULL, NULL);
356
 
        _tmp0_ = json_parser_get_root (self->priv->parser);
357
 
        self->priv->node = _tmp0_;
 
479
        _tmp0_ = self->priv->parser;
 
480
        _tmp1_ = json_parser_get_root (_tmp0_);
 
481
        self->priv->node = _tmp1_;
358
482
        result = self;
359
483
        return result;
360
484
}
362
486
 
363
487
static gboolean json_soup_is_value (JsonSoup* self) {
364
488
        gboolean result = FALSE;
365
 
        JsonNodeType _tmp0_;
 
489
        JsonNode* _tmp0_;
 
490
        JsonNodeType _tmp1_ = 0;
366
491
        g_return_val_if_fail (self != NULL, FALSE);
367
 
        _tmp0_ = json_node_get_node_type (self->priv->node);
368
 
        if (_tmp0_ == JSON_NODE_VALUE) {
 
492
        _tmp0_ = self->priv->node;
 
493
        _tmp1_ = json_node_get_node_type (_tmp0_);
 
494
        if (_tmp1_ == JSON_NODE_VALUE) {
369
495
                result = TRUE;
370
496
                return result;
371
497
        } else {
377
503
 
378
504
gboolean json_soup_is_object (JsonSoup* self) {
379
505
        gboolean result = FALSE;
380
 
        JsonNodeType _tmp0_;
 
506
        JsonNode* _tmp0_;
 
507
        JsonNodeType _tmp1_ = 0;
381
508
        g_return_val_if_fail (self != NULL, FALSE);
382
 
        _tmp0_ = json_node_get_node_type (self->priv->node);
383
 
        result = _tmp0_ == JSON_NODE_OBJECT;
 
509
        _tmp0_ = self->priv->node;
 
510
        _tmp1_ = json_node_get_node_type (_tmp0_);
 
511
        result = _tmp1_ == JSON_NODE_OBJECT;
384
512
        return result;
385
513
}
386
514
 
387
515
 
388
516
gboolean json_soup_is_array (JsonSoup* self) {
389
517
        gboolean result = FALSE;
390
 
        JsonNodeType _tmp0_;
 
518
        JsonNode* _tmp0_;
 
519
        JsonNodeType _tmp1_ = 0;
391
520
        g_return_val_if_fail (self != NULL, FALSE);
392
 
        _tmp0_ = json_node_get_node_type (self->priv->node);
393
 
        result = _tmp0_ == JSON_NODE_ARRAY;
 
521
        _tmp0_ = self->priv->node;
 
522
        _tmp1_ = json_node_get_node_type (_tmp0_);
 
523
        result = _tmp1_ == JSON_NODE_ARRAY;
394
524
        return result;
395
525
}
396
526
 
397
527
 
398
528
gboolean json_soup_is_string (JsonSoup* self) {
399
529
        gboolean result = FALSE;
400
 
        gboolean _tmp0_;
401
 
        GType _tmp1_;
 
530
        gboolean _tmp0_ = FALSE;
 
531
        JsonNode* _tmp1_;
 
532
        GType _tmp2_ = 0UL;
402
533
        g_return_val_if_fail (self != NULL, FALSE);
403
534
        _tmp0_ = json_soup_is_value (self);
404
535
        if (_tmp0_ == FALSE) {
405
536
                result = FALSE;
406
537
                return result;
407
538
        }
408
 
        _tmp1_ = json_node_get_value_type (self->priv->node);
409
 
        result = _tmp1_ == G_TYPE_STRING;
 
539
        _tmp1_ = self->priv->node;
 
540
        _tmp2_ = json_node_get_value_type (_tmp1_);
 
541
        result = _tmp2_ == G_TYPE_STRING;
410
542
        return result;
411
543
}
412
544
 
413
545
 
414
546
gboolean json_soup_is_int (JsonSoup* self) {
415
547
        gboolean result = FALSE;
416
 
        gboolean _tmp0_;
417
 
        GType _tmp1_;
 
548
        gboolean _tmp0_ = FALSE;
 
549
        JsonNode* _tmp1_;
 
550
        GType _tmp2_ = 0UL;
418
551
        g_return_val_if_fail (self != NULL, FALSE);
419
552
        _tmp0_ = json_soup_is_value (self);
420
553
        if (_tmp0_ == FALSE) {
421
554
                result = FALSE;
422
555
                return result;
423
556
        }
424
 
        _tmp1_ = json_node_get_value_type (self->priv->node);
425
 
        result = _tmp1_ == G_TYPE_INT64;
 
557
        _tmp1_ = self->priv->node;
 
558
        _tmp2_ = json_node_get_value_type (_tmp1_);
 
559
        result = _tmp2_ == G_TYPE_INT64;
426
560
        return result;
427
561
}
428
562
 
429
563
 
430
564
gboolean json_soup_is_double (JsonSoup* self) {
431
565
        gboolean result = FALSE;
432
 
        gboolean _tmp0_;
433
 
        GType _tmp1_;
 
566
        gboolean _tmp0_ = FALSE;
 
567
        JsonNode* _tmp1_;
 
568
        GType _tmp2_ = 0UL;
434
569
        g_return_val_if_fail (self != NULL, FALSE);
435
570
        _tmp0_ = json_soup_is_value (self);
436
571
        if (_tmp0_ == FALSE) {
437
572
                result = FALSE;
438
573
                return result;
439
574
        }
440
 
        _tmp1_ = json_node_get_value_type (self->priv->node);
441
 
        result = _tmp1_ == G_TYPE_DOUBLE;
 
575
        _tmp1_ = self->priv->node;
 
576
        _tmp2_ = json_node_get_value_type (_tmp1_);
 
577
        result = _tmp2_ == G_TYPE_DOUBLE;
442
578
        return result;
443
579
}
444
580
 
445
581
 
446
582
gboolean json_soup_is_bool (JsonSoup* self) {
447
583
        gboolean result = FALSE;
448
 
        gboolean _tmp0_;
449
 
        GType _tmp1_;
 
584
        gboolean _tmp0_ = FALSE;
 
585
        JsonNode* _tmp1_;
 
586
        GType _tmp2_ = 0UL;
450
587
        g_return_val_if_fail (self != NULL, FALSE);
451
588
        _tmp0_ = json_soup_is_value (self);
452
589
        if (_tmp0_ == FALSE) {
453
590
                result = FALSE;
454
591
                return result;
455
592
        }
456
 
        _tmp1_ = json_node_get_value_type (self->priv->node);
457
 
        result = _tmp1_ == G_TYPE_BOOLEAN;
 
593
        _tmp1_ = self->priv->node;
 
594
        _tmp2_ = json_node_get_value_type (_tmp1_);
 
595
        result = _tmp2_ == G_TYPE_BOOLEAN;
458
596
        return result;
459
597
}
460
598
 
461
599
 
462
600
gchar* json_soup_get_string (JsonSoup* self) {
463
601
        gchar* result = NULL;
464
 
        const gchar* _tmp0_ = NULL;
465
 
        gchar* _tmp1_;
 
602
        JsonNode* _tmp0_;
 
603
        const gchar* _tmp1_ = NULL;
 
604
        gchar* _tmp2_;
466
605
        g_return_val_if_fail (self != NULL, NULL);
467
 
        _tmp0_ = json_node_get_string (self->priv->node);
468
 
        _tmp1_ = g_strdup (_tmp0_);
469
 
        result = _tmp1_;
 
606
        _tmp0_ = self->priv->node;
 
607
        _tmp1_ = json_node_get_string (_tmp0_);
 
608
        _tmp2_ = g_strdup (_tmp1_);
 
609
        result = _tmp2_;
470
610
        return result;
471
611
}
472
612
 
473
613
 
474
614
gint64 json_soup_get_int (JsonSoup* self) {
475
615
        gint64 result = 0LL;
476
 
        gint64 _tmp0_;
 
616
        JsonNode* _tmp0_;
 
617
        gint64 _tmp1_ = 0LL;
477
618
        g_return_val_if_fail (self != NULL, 0LL);
478
 
        _tmp0_ = json_node_get_int (self->priv->node);
479
 
        result = _tmp0_;
 
619
        _tmp0_ = self->priv->node;
 
620
        _tmp1_ = json_node_get_int (_tmp0_);
 
621
        result = _tmp1_;
480
622
        return result;
481
623
}
482
624
 
483
625
 
484
626
gdouble json_soup_get_double (JsonSoup* self) {
485
627
        gdouble result = 0.0;
486
 
        gdouble _tmp0_;
 
628
        JsonNode* _tmp0_;
 
629
        gdouble _tmp1_ = 0.0;
487
630
        g_return_val_if_fail (self != NULL, 0.0);
488
 
        _tmp0_ = json_node_get_double (self->priv->node);
489
 
        result = _tmp0_;
 
631
        _tmp0_ = self->priv->node;
 
632
        _tmp1_ = json_node_get_double (_tmp0_);
 
633
        result = _tmp1_;
490
634
        return result;
491
635
}
492
636
 
493
637
 
494
638
gboolean json_soup_get_bool (JsonSoup* self) {
495
639
        gboolean result = FALSE;
496
 
        gboolean _tmp0_;
 
640
        JsonNode* _tmp0_;
 
641
        gboolean _tmp1_ = FALSE;
497
642
        g_return_val_if_fail (self != NULL, FALSE);
498
 
        _tmp0_ = json_node_get_boolean (self->priv->node);
499
 
        result = _tmp0_;
 
643
        _tmp0_ = self->priv->node;
 
644
        _tmp1_ = json_node_get_boolean (_tmp0_);
 
645
        result = _tmp1_;
500
646
        return result;
501
647
}
502
648
 
503
649
 
504
650
gint json_soup_length (JsonSoup* self) {
505
651
        gint result = 0;
506
 
        gboolean _tmp0_;
507
 
        JsonArray* _tmp1_ = NULL;
508
 
        JsonArray* _tmp2_;
 
652
        gboolean _tmp0_ = FALSE;
 
653
        JsonNode* _tmp1_;
 
654
        JsonArray* _tmp2_ = NULL;
 
655
        JsonArray* _tmp3_;
509
656
        JsonArray* array;
510
 
        guint _tmp3_;
 
657
        JsonArray* _tmp4_;
 
658
        guint _tmp5_ = 0U;
511
659
        g_return_val_if_fail (self != NULL, 0);
512
660
        _tmp0_ = json_soup_is_array (self);
513
661
        if (_tmp0_ == FALSE) {
514
662
                result = 0;
515
663
                return result;
516
664
        }
517
 
        _tmp1_ = json_node_get_array (self->priv->node);
518
 
        _tmp2_ = _json_array_ref0 (_tmp1_);
519
 
        array = _tmp2_;
520
 
        _tmp3_ = json_array_get_length (array);
521
 
        result = (gint) _tmp3_;
522
 
        _json_array_unref0 (array);
 
665
        _tmp1_ = self->priv->node;
 
666
        _tmp2_ = json_node_get_array (_tmp1_);
 
667
        _tmp3_ = __vala_JsonArray_copy0 (_tmp2_);
 
668
        array = _tmp3_;
 
669
        _tmp4_ = array;
 
670
        _tmp5_ = json_array_get_length (_tmp4_);
 
671
        result = (gint) _tmp5_;
 
672
        __vala_JsonArray_free0 (array);
523
673
        return result;
524
674
}
525
675