← Back to branch summary

~ubuntu-branches/debian/sid/sqlheavy/sid

« back to all changes in this revision

Viewing changes to examples/async.c

  • Committer: Package Import Robot
  • Author(s): Devid Antonio Filoni
  • Date: 2011-10-23 15:43:22 UTC
  • Revision ID: package-import@ubuntu.com-20111023154322-unzj3fz2aj4g6cl8
Tags: upstream-0.1.0
Import upstream version 0.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/async.c
 
1
/* async.c generated by valac 0.12.1, the Vala compiler
 
2
 * generated from async.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include <gio/gio.h>
 
8
#include <SQLHeavy.h>
 
9
#include <stdlib.h>
 
10
#include <string.h>
 
11
 
 
12
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
13
typedef struct _Block1Data Block1Data;
 
14
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
15
typedef struct _TestData TestData;
 
16
#define __vala_GValue_free0(var) ((var == NULL) ? NULL : (var = (_vala_GValue_free (var), NULL)))
 
17
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
 
18
 
 
19
struct _Block1Data {
 
20
        int _ref_count_;
 
21
        GCancellable* cancellable;
 
22
        gpointer _async_data_;
 
23
};
 
24
 
 
25
struct _TestData {
 
26
        int _state_;
 
27
        GObject* _source_object_;
 
28
        GAsyncResult* _res_;
 
29
        GSimpleAsyncResult* _async_result;
 
30
        SQLHeavyDatabase* db;
 
31
        Block1Data* _data1_;
 
32
        guint _tmp0_;
 
33
        guint id;
 
34
        SQLHeavyQuery* _tmp1_;
 
35
        SQLHeavyQuery* stmt;
 
36
        GCancellable* _tmp2_;
 
37
        SQLHeavyQueryResult* _tmp3_;
 
38
        SQLHeavyQueryResult* _tmp4_;
 
39
        GError * e;
 
40
        GError * _inner_error_;
 
41
};
 
42
 
 
43
 
 
44
extern GMainLoop* loop;
 
45
GMainLoop* loop = NULL;
 
46
 
 
47
static void test_data_free (gpointer _data);
 
48
void test (SQLHeavyDatabase* db, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
49
void test_finish (GAsyncResult* _res_);
 
50
static gboolean test_co (TestData* data);
 
51
static Block1Data* block1_data_ref (Block1Data* _data1_);
 
52
static void block1_data_unref (Block1Data* _data1_);
 
53
static gboolean _lambda0_ (Block1Data* _data1_);
 
54
static gboolean __lambda0__gsource_func (gpointer self);
 
55
static void test_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
56
gint _vala_main (gchar** args, int args_length1);
 
57
static void _vala_GValue_free (GValue* self);
 
58
 
 
59
 
 
60
static void test_data_free (gpointer _data) {
 
61
        TestData* data;
 
62
        data = _data;
 
63
        _g_object_unref0 (data->db);
 
64
        g_slice_free (TestData, data);
 
65
}
 
66
 
 
67
 
 
68
static gpointer _g_object_ref0 (gpointer self) {
 
69
        return self ? g_object_ref (self) : NULL;
 
70
}
 
71
 
 
72
 
 
73
void test (SQLHeavyDatabase* db, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
74
        TestData* _data_;
 
75
        _data_ = g_slice_new0 (TestData);
 
76
        _data_->_async_result = g_simple_async_result_new (g_object_newv (G_TYPE_OBJECT, 0, NULL), _callback_, _user_data_, test);
 
77
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, test_data_free);
 
78
        _data_->db = _g_object_ref0 (db);
 
79
        test_co (_data_);
 
80
}
 
81
 
 
82
 
 
83
void test_finish (GAsyncResult* _res_) {
 
84
        TestData* _data_;
 
85
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
86
}
 
87
 
 
88
 
 
89
/**
 
90
 * Some basic testing for the asnychronous functions.
 
91
 */
 
92
static Block1Data* block1_data_ref (Block1Data* _data1_) {
 
93
        g_atomic_int_inc (&_data1_->_ref_count_);
 
94
        return _data1_;
 
95
}
 
96
 
 
97
 
 
98
static void block1_data_unref (Block1Data* _data1_) {
 
99
        if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
 
100
                _g_object_unref0 (_data1_->cancellable);
 
101
                g_slice_free (Block1Data, _data1_);
 
102
        }
 
103
}
 
104
 
 
105
 
 
106
static gboolean _lambda0_ (Block1Data* _data1_) {
 
107
        gboolean result = FALSE;
 
108
        if (_data1_->cancellable != NULL) {
 
109
                g_debug ("async.vala:10: Canceling...");
 
110
                g_cancellable_cancel (_data1_->cancellable);
 
111
                result = FALSE;
 
112
                return result;
 
113
        }
 
114
        g_debug ("async.vala:14: Tick");
 
115
        result = TRUE;
 
116
        return result;
 
117
}
 
118
 
 
119
 
 
120
static gboolean __lambda0__gsource_func (gpointer self) {
 
121
        gboolean result;
 
122
        result = _lambda0_ (self);
 
123
        return result;
 
124
}
 
125
 
 
126
 
 
127
static void test_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
128
        TestData* data;
 
129
        data = _user_data_;
 
130
        data->_source_object_ = source_object;
 
131
        data->_res_ = _res_;
 
132
        test_co (data);
 
133
}
 
134
 
 
135
 
 
136
static gboolean test_co (TestData* data) {
 
137
        switch (data->_state_) {
 
138
                case 0:
 
139
                goto _state_0;
 
140
                case 1:
 
141
                goto _state_1;
 
142
                default:
 
143
                g_assert_not_reached ();
 
144
        }
 
145
        _state_0:
 
146
        data->_data1_ = g_slice_new0 (Block1Data);
 
147
        data->_data1_->_ref_count_ = 1;
 
148
        data->_data1_->_async_data_ = data;
 
149
        data->_data1_->cancellable = NULL;
 
150
        data->_tmp0_ = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 1, __lambda0__gsource_func, block1_data_ref (data->_data1_), block1_data_unref);
 
151
        data->id = data->_tmp0_;
 
152
        g_debug ("async.vala:18: Running query...");
 
153
        data->_tmp1_ = NULL;
 
154
        data->_tmp1_ = sql_heavy_queryable_prepare ((SQLHeavyQueryable*) data->db, "UPDATE `foo` SET `bar` = ((`bar` + 1729) / 7) % 3;", &data->_inner_error_);
 
155
        data->stmt = data->_tmp1_;
 
156
        if (data->_inner_error_ != NULL) {
 
157
                if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
 
158
                        goto __catch0_sql_heavy_error;
 
159
                }
 
160
                block1_data_unref (data->_data1_);
 
161
                data->_data1_ = NULL;
 
162
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
163
                g_clear_error (&data->_inner_error_);
 
164
                return FALSE;
 
165
        }
 
166
        data->_tmp2_ = NULL;
 
167
        data->_tmp2_ = g_cancellable_new ();
 
168
        _g_object_unref0 (data->_data1_->cancellable);
 
169
        data->_data1_->cancellable = data->_tmp2_;
 
170
        data->_state_ = 1;
 
171
        sql_heavy_query_execute_async (data->stmt, data->_data1_->cancellable, test_ready, data);
 
172
        return FALSE;
 
173
        _state_1:
 
174
        data->_tmp3_ = NULL;
 
175
        data->_tmp3_ = sql_heavy_query_execute_finish (data->stmt, data->_res_, &data->_inner_error_);
 
176
        data->_tmp4_ = data->_tmp3_;
 
177
        _g_object_unref0 (data->_tmp4_);
 
178
        if (data->_inner_error_ != NULL) {
 
179
                _g_object_unref0 (data->stmt);
 
180
                if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
 
181
                        goto __catch0_sql_heavy_error;
 
182
                }
 
183
                _g_object_unref0 (data->stmt);
 
184
                block1_data_unref (data->_data1_);
 
185
                data->_data1_ = NULL;
 
186
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
187
                g_clear_error (&data->_inner_error_);
 
188
                return FALSE;
 
189
        }
 
190
        _g_object_unref0 (data->stmt);
 
191
        goto __finally0;
 
192
        __catch0_sql_heavy_error:
 
193
        {
 
194
                data->e = data->_inner_error_;
 
195
                data->_inner_error_ = NULL;
 
196
                if (g_error_matches (data->e, SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_INTERRUPTED)) {
 
197
                        g_debug ("async.vala:26: Query canceled.");
 
198
                } else {
 
199
                        g_error ("async.vala:28: Execution threw an error: %s (%d)", data->e->message, data->e->code);
 
200
                }
 
201
                _g_error_free0 (data->e);
 
202
        }
 
203
        __finally0:
 
204
        if (data->_inner_error_ != NULL) {
 
205
                block1_data_unref (data->_data1_);
 
206
                data->_data1_ = NULL;
 
207
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
208
                g_clear_error (&data->_inner_error_);
 
209
                return FALSE;
 
210
        }
 
211
        g_debug ("async.vala:30: Finished running query.");
 
212
        g_source_remove (data->id);
 
213
        g_main_loop_quit (loop);
 
214
        block1_data_unref (data->_data1_);
 
215
        data->_data1_ = NULL;
 
216
        if (data->_state_ == 0) {
 
217
                g_simple_async_result_complete_in_idle (data->_async_result);
 
218
        } else {
 
219
                g_simple_async_result_complete (data->_async_result);
 
220
        }
 
221
        g_object_unref (data->_async_result);
 
222
        return FALSE;
 
223
}
 
224
 
 
225
 
 
226
static void _vala_GValue_free (GValue* self) {
 
227
        g_value_unset (self);
 
228
        g_free (self);
 
229
}
 
230
 
 
231
 
 
232
gint _vala_main (gchar** args, int args_length1) {
 
233
        gint result = 0;
 
234
        SQLHeavyDatabase* _tmp0_ = NULL;
 
235
        SQLHeavyDatabase* db;
 
236
        SQLHeavyQuery* _tmp1_ = NULL;
 
237
        SQLHeavyQuery* stmt;
 
238
        SQLHeavyQueryResult* _tmp2_ = NULL;
 
239
        SQLHeavyQueryResult* _tmp3_;
 
240
        SQLHeavyTransaction* _tmp4_ = NULL;
 
241
        SQLHeavyTransaction* trans;
 
242
        SQLHeavyQuery* _tmp5_ = NULL;
 
243
        SQLHeavyQuery* _tmp6_;
 
244
        GMainLoop* _tmp11_ = NULL;
 
245
        GError * _inner_error_ = NULL;
 
246
        _tmp0_ = sql_heavy_database_new (NULL, (SQL_HEAVY_FILE_MODE_READ | SQL_HEAVY_FILE_MODE_WRITE) | SQL_HEAVY_FILE_MODE_CREATE, &_inner_error_);
 
247
        db = _tmp0_;
 
248
        if (_inner_error_ != NULL) {
 
249
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
250
                        goto __catch1_sql_heavy_error;
 
251
                }
 
252
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
253
                g_clear_error (&_inner_error_);
 
254
                return 0;
 
255
        }
 
256
        _tmp1_ = sql_heavy_queryable_prepare ((SQLHeavyQueryable*) db, "CREATE TABLE `foo` ( `bar` INT );", &_inner_error_);
 
257
        stmt = _tmp1_;
 
258
        if (_inner_error_ != NULL) {
 
259
                _g_object_unref0 (db);
 
260
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
261
                        goto __catch1_sql_heavy_error;
 
262
                }
 
263
                _g_object_unref0 (db);
 
264
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
265
                g_clear_error (&_inner_error_);
 
266
                return 0;
 
267
        }
 
268
        _tmp2_ = sql_heavy_query_execute (stmt, NULL, &_inner_error_, NULL);
 
269
        _tmp3_ = _tmp2_;
 
270
        _g_object_unref0 (_tmp3_);
 
271
        if (_inner_error_ != NULL) {
 
272
                _g_object_unref0 (stmt);
 
273
                _g_object_unref0 (db);
 
274
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
275
                        goto __catch1_sql_heavy_error;
 
276
                }
 
277
                _g_object_unref0 (stmt);
 
278
                _g_object_unref0 (db);
 
279
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
280
                g_clear_error (&_inner_error_);
 
281
                return 0;
 
282
        }
 
283
        g_debug ("async.vala:45: Populating database...");
 
284
        _tmp4_ = sql_heavy_queryable_begin_transaction ((SQLHeavyQueryable*) db, &_inner_error_);
 
285
        trans = _tmp4_;
 
286
        if (_inner_error_ != NULL) {
 
287
                _g_object_unref0 (stmt);
 
288
                _g_object_unref0 (db);
 
289
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
290
                        goto __catch1_sql_heavy_error;
 
291
                }
 
292
                _g_object_unref0 (stmt);
 
293
                _g_object_unref0 (db);
 
294
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
295
                g_clear_error (&_inner_error_);
 
296
                return 0;
 
297
        }
 
298
        _tmp5_ = sql_heavy_queryable_prepare ((SQLHeavyQueryable*) trans, "INSERT INTO `foo` (`bar`) VALUES (:value);", &_inner_error_);
 
299
        _tmp6_ = _tmp5_;
 
300
        if (_inner_error_ != NULL) {
 
301
                _g_object_unref0 (trans);
 
302
                _g_object_unref0 (stmt);
 
303
                _g_object_unref0 (db);
 
304
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
305
                        goto __catch1_sql_heavy_error;
 
306
                }
 
307
                _g_object_unref0 (trans);
 
308
                _g_object_unref0 (stmt);
 
309
                _g_object_unref0 (db);
 
310
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
311
                g_clear_error (&_inner_error_);
 
312
                return 0;
 
313
        }
 
314
        _g_object_unref0 (stmt);
 
315
        stmt = _tmp6_;
 
316
        {
 
317
                gint i;
 
318
                i = 0;
 
319
                {
 
320
                        gboolean _tmp7_;
 
321
                        _tmp7_ = TRUE;
 
322
                        while (TRUE) {
 
323
                                GValue* _tmp8_ = NULL;
 
324
                                SQLHeavyQueryResult* _tmp9_ = NULL;
 
325
                                SQLHeavyQueryResult* _tmp10_;
 
326
                                if (!_tmp7_) {
 
327
                                        i++;
 
328
                                }
 
329
                                _tmp7_ = FALSE;
 
330
                                if (!(i < (65536 * 8))) {
 
331
                                        break;
 
332
                                }
 
333
                                if ((i & 0xffff) == 0xffff) {
 
334
                                        g_debug ("async.vala:51: %d...", i);
 
335
                                }
 
336
                                _tmp8_ = g_new0 (GValue, 1);
 
337
                                g_value_init (_tmp8_, G_TYPE_INT);
 
338
                                g_value_set_int (_tmp8_, i);
 
339
                                sql_heavy_query_set (stmt, ":value", _tmp8_, &_inner_error_);
 
340
                                __vala_GValue_free0 (_tmp8_);
 
341
                                if (_inner_error_ != NULL) {
 
342
                                        _g_object_unref0 (trans);
 
343
                                        _g_object_unref0 (stmt);
 
344
                                        _g_object_unref0 (db);
 
345
                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
346
                                                goto __catch1_sql_heavy_error;
 
347
                                        }
 
348
                                        _g_object_unref0 (trans);
 
349
                                        _g_object_unref0 (stmt);
 
350
                                        _g_object_unref0 (db);
 
351
                                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
352
                                        g_clear_error (&_inner_error_);
 
353
                                        return 0;
 
354
                                }
 
355
                                _tmp9_ = sql_heavy_query_execute (stmt, NULL, &_inner_error_, NULL);
 
356
                                _tmp10_ = _tmp9_;
 
357
                                _g_object_unref0 (_tmp10_);
 
358
                                if (_inner_error_ != NULL) {
 
359
                                        _g_object_unref0 (trans);
 
360
                                        _g_object_unref0 (stmt);
 
361
                                        _g_object_unref0 (db);
 
362
                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
363
                                                goto __catch1_sql_heavy_error;
 
364
                                        }
 
365
                                        _g_object_unref0 (trans);
 
366
                                        _g_object_unref0 (stmt);
 
367
                                        _g_object_unref0 (db);
 
368
                                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
369
                                        g_clear_error (&_inner_error_);
 
370
                                        return 0;
 
371
                                }
 
372
                        }
 
373
                }
 
374
        }
 
375
        sql_heavy_transaction_commit (trans, &_inner_error_);
 
376
        if (_inner_error_ != NULL) {
 
377
                _g_object_unref0 (trans);
 
378
                _g_object_unref0 (stmt);
 
379
                _g_object_unref0 (db);
 
380
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
381
                        goto __catch1_sql_heavy_error;
 
382
                }
 
383
                _g_object_unref0 (trans);
 
384
                _g_object_unref0 (stmt);
 
385
                _g_object_unref0 (db);
 
386
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
387
                g_clear_error (&_inner_error_);
 
388
                return 0;
 
389
        }
 
390
        test (db, NULL, NULL);
 
391
        _g_object_unref0 (trans);
 
392
        _g_object_unref0 (stmt);
 
393
        _g_object_unref0 (db);
 
394
        goto __finally1;
 
395
        __catch1_sql_heavy_error:
 
396
        {
 
397
                GError * e;
 
398
                e = _inner_error_;
 
399
                _inner_error_ = NULL;
 
400
                g_debug ("async.vala:61: Error: %s (%d)", e->message, e->code);
 
401
                _g_error_free0 (e);
 
402
        }
 
403
        __finally1:
 
404
        if (_inner_error_ != NULL) {
 
405
                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);
 
406
                g_clear_error (&_inner_error_);
 
407
                return 0;
 
408
        }
 
409
        _tmp11_ = g_main_loop_new (NULL, FALSE);
 
410
        _g_main_loop_unref0 (loop);
 
411
        loop = _tmp11_;
 
412
        g_main_loop_run (loop);
 
413
        result = 0;
 
414
        return result;
 
415
}
 
416
 
 
417
 
 
418
int main (int argc, char ** argv) {
 
419
        g_type_init ();
 
420
        return _vala_main (argv, argc);
 
421
}
 
422
 
 
423
 
 
424