← Back to branch summary

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

« back to all changes in this revision

Viewing changes to sqlheavy/sqlheavy-transaction.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:
sqlheavy/sqlheavy-transaction.c
 
1
/* sqlheavy-transaction.c generated by valac 0.12.1, the Vala compiler
 
2
 * generated from sqlheavy-transaction.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include "SQLHeavy.h"
 
8
#include <sqlite3.h>
 
9
#include <stdlib.h>
 
10
#include <string.h>
 
11
#include <gio/gio.h>
 
12
 
 
13
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
14
#define _sqlite3_mutex_free0(var) ((var == NULL) ? NULL : (var = (sqlite3_mutex_free (var), NULL)))
 
15
#define _g_sequence_free0(var) ((var == NULL) ? NULL : (var = (g_sequence_free (var), NULL)))
 
16
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
17
#define _g_free0(var) (var = (g_free (var), NULL))
 
18
typedef struct _SqlHeavyTransactionResolveAsyncData SqlHeavyTransactionResolveAsyncData;
 
19
typedef struct _SqlHeavyTransactionCommitAsyncData SqlHeavyTransactionCommitAsyncData;
 
20
typedef struct _SqlHeavyTransactionRollbackAsyncData SqlHeavyTransactionRollbackAsyncData;
 
21
 
 
22
struct _SQLHeavyTransactionPrivate {
 
23
        SQLHeavyTransactionStatus _status;
 
24
        SQLHeavyQueryable* _parent;
 
25
        sqlite3_mutex* _transaction_lock;
 
26
        GSequence* _queue;
 
27
        GStaticRecMutex __lock__queue;
 
28
        GError* err;
 
29
};
 
30
 
 
31
struct _SqlHeavyTransactionResolveAsyncData {
 
32
        int _state_;
 
33
        GObject* _source_object_;
 
34
        GAsyncResult* _res_;
 
35
        GSimpleAsyncResult* _async_result;
 
36
        SQLHeavyTransaction* self;
 
37
        gboolean commit;
 
38
        GError* _tmp0_;
 
39
        const gchar* _tmp1_;
 
40
        gchar* _tmp2_;
 
41
        gchar* _tmp3_;
 
42
        SQLHeavyQuery* _tmp4_;
 
43
        SQLHeavyQuery* _tmp5_;
 
44
        SQLHeavyQuery* query;
 
45
        SQLHeavyQueryResult* _tmp6_;
 
46
        SQLHeavyQueryResult* _tmp7_;
 
47
        SQLHeavyTransactionStatus _tmp8_;
 
48
        GError * _inner_error_;
 
49
};
 
50
 
 
51
struct _SqlHeavyTransactionCommitAsyncData {
 
52
        int _state_;
 
53
        GObject* _source_object_;
 
54
        GAsyncResult* _res_;
 
55
        GSimpleAsyncResult* _async_result;
 
56
        SQLHeavyTransaction* self;
 
57
        GError * _inner_error_;
 
58
};
 
59
 
 
60
struct _SqlHeavyTransactionRollbackAsyncData {
 
61
        int _state_;
 
62
        GObject* _source_object_;
 
63
        GAsyncResult* _res_;
 
64
        GSimpleAsyncResult* _async_result;
 
65
        SQLHeavyTransaction* self;
 
66
        GError * _inner_error_;
 
67
};
 
68
 
 
69
 
 
70
static gpointer sql_heavy_transaction_parent_class = NULL;
 
71
static SQLHeavyQueryableIface* sql_heavy_transaction_sql_heavy_queryable_parent_iface = NULL;
 
72
 
 
73
#define SQL_HEAVY_TRANSACTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SQL_HEAVY_TYPE_TRANSACTION, SQLHeavyTransactionPrivate))
 
74
enum  {
 
75
        SQL_HEAVY_TRANSACTION_DUMMY_PROPERTY,
 
76
        SQL_HEAVY_TRANSACTION_STATUS,
 
77
        SQL_HEAVY_TRANSACTION_PARENT,
 
78
        SQL_HEAVY_TRANSACTION_DATABASE
 
79
};
 
80
static void sql_heavy_transaction_real_lock (SQLHeavyQueryable* base);
 
81
static void sql_heavy_transaction_real_unlock (SQLHeavyQueryable* base);
 
82
SQLHeavyQueryResult* sql_heavy_query_result_new_no_exec (SQLHeavyQuery* query, GError** error);
 
83
SQLHeavyQueryResult* sql_heavy_query_result_construct_no_exec (GType object_type, SQLHeavyQuery* query, GError** error);
 
84
gboolean sql_heavy_query_result_next_internal (SQLHeavyQueryResult* self, GError** error);
 
85
static void sql_heavy_transaction_real_queue (SQLHeavyQueryable* base, SQLHeavyQuery* query, GError** error);
 
86
static void sql_heavy_transaction_resolve (SQLHeavyTransaction* self, gboolean commit, GError** error);
 
87
static void sql_heavy_transaction_set_status (SQLHeavyTransaction* self, SQLHeavyTransactionStatus value);
 
88
static void sql_heavy_transaction_resolve_async_data_free (gpointer _data);
 
89
static void sql_heavy_transaction_resolve_async (SQLHeavyTransaction* self, gboolean commit, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
90
static void sql_heavy_transaction_resolve_finish (SQLHeavyTransaction* self, GAsyncResult* _res_, GError** error);
 
91
static gboolean sql_heavy_transaction_resolve_async_co (SqlHeavyTransactionResolveAsyncData* data);
 
92
static void sql_heavy_transaction_resolve_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
93
static void sql_heavy_transaction_commit_async_data_free (gpointer _data);
 
94
static gboolean sql_heavy_transaction_commit_async_co (SqlHeavyTransactionCommitAsyncData* data);
 
95
static void sql_heavy_transaction_commit_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
96
static void sql_heavy_transaction_rollback_async_data_free (gpointer _data);
 
97
static gboolean sql_heavy_transaction_rollback_async_co (SqlHeavyTransactionRollbackAsyncData* data);
 
98
static void sql_heavy_transaction_rollback_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
99
static GObject * sql_heavy_transaction_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 
100
static void sql_heavy_transaction_finalize (GObject* obj);
 
101
static void _vala_sql_heavy_transaction_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
102
static void _vala_sql_heavy_transaction_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
103
 
 
104
 
 
105
/**
 
106
     * {@inheritDoc}
 
107
     */
 
108
static void sql_heavy_transaction_real_lock (SQLHeavyQueryable* base) {
 
109
        SQLHeavyTransaction * self;
 
110
        self = (SQLHeavyTransaction*) base;
 
111
        sqlite3_mutex_enter (self->priv->_transaction_lock);
 
112
}
 
113
 
 
114
 
 
115
/**
 
116
     * {@inheritDoc}
 
117
     */
 
118
static void sql_heavy_transaction_real_unlock (SQLHeavyQueryable* base) {
 
119
        SQLHeavyTransaction * self;
 
120
        GError * _inner_error_ = NULL;
 
121
        self = (SQLHeavyTransaction*) base;
 
122
        {
 
123
                gboolean _tmp0_ = FALSE;
 
124
                g_static_rec_mutex_lock (&self->priv->__lock__queue);
 
125
                if (self->priv->_queue != NULL) {
 
126
                        gint _tmp1_;
 
127
                        _tmp1_ = g_sequence_get_length (self->priv->_queue);
 
128
                        _tmp0_ = _tmp1_ > 0;
 
129
                } else {
 
130
                        _tmp0_ = FALSE;
 
131
                }
 
132
                if (_tmp0_) {
 
133
                        {
 
134
                                GSequenceIter* _tmp2_ = NULL;
 
135
                                GSequenceIter* iter;
 
136
                                _tmp2_ = g_sequence_get_begin_iter (self->priv->_queue);
 
137
                                iter = _tmp2_;
 
138
                                {
 
139
                                        gboolean _tmp3_;
 
140
                                        _tmp3_ = TRUE;
 
141
                                        while (TRUE) {
 
142
                                                gboolean _tmp5_;
 
143
                                                gconstpointer _tmp6_ = NULL;
 
144
                                                SQLHeavyQueryResult* _tmp7_ = NULL;
 
145
                                                SQLHeavyQueryResult* _result_;
 
146
                                                if (!_tmp3_) {
 
147
                                                        GSequenceIter* _tmp4_ = NULL;
 
148
                                                        _tmp4_ = g_sequence_iter_next (iter);
 
149
                                                        iter = _tmp4_;
 
150
                                                }
 
151
                                                _tmp3_ = FALSE;
 
152
                                                _tmp5_ = g_sequence_iter_is_end (iter);
 
153
                                                if (!(!_tmp5_)) {
 
154
                                                        break;
 
155
                                                }
 
156
                                                _tmp6_ = g_sequence_get (iter);
 
157
                                                _tmp7_ = sql_heavy_query_result_new_no_exec ((SQLHeavyQuery*) _tmp6_, &_inner_error_);
 
158
                                                _result_ = _tmp7_;
 
159
                                                if (_inner_error_ != NULL) {
 
160
                                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
161
                                                                goto __catch44_sql_heavy_error;
 
162
                                                        }
 
163
                                                        g_static_rec_mutex_unlock (&self->priv->__lock__queue);
 
164
                                                        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);
 
165
                                                        g_clear_error (&_inner_error_);
 
166
                                                        return;
 
167
                                                }
 
168
                                                sql_heavy_query_result_next_internal (_result_, &_inner_error_);
 
169
                                                if (_inner_error_ != NULL) {
 
170
                                                        _g_object_unref0 (_result_);
 
171
                                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
172
                                                                goto __catch44_sql_heavy_error;
 
173
                                                        }
 
174
                                                        _g_object_unref0 (_result_);
 
175
                                                        g_static_rec_mutex_unlock (&self->priv->__lock__queue);
 
176
                                                        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);
 
177
                                                        g_clear_error (&_inner_error_);
 
178
                                                        return;
 
179
                                                }
 
180
                                                g_sequence_remove (iter);
 
181
                                                _g_object_unref0 (_result_);
 
182
                                        }
 
183
                                }
 
184
                        }
 
185
                        goto __finally44;
 
186
                        __catch44_sql_heavy_error:
 
187
                        {
 
188
                                GError * e;
 
189
                                e = _inner_error_;
 
190
                                _inner_error_ = NULL;
 
191
                                g_critical ("sqlheavy-transaction.vala:53: Unable to execute queued query: %s", e->message);
 
192
                                _g_error_free0 (e);
 
193
                        }
 
194
                        __finally44:
 
195
                        if (_inner_error_ != NULL) {
 
196
                                g_static_rec_mutex_unlock (&self->priv->__lock__queue);
 
197
                                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);
 
198
                                g_clear_error (&_inner_error_);
 
199
                                return;
 
200
                        }
 
201
                }
 
202
                __finally43:
 
203
                g_static_rec_mutex_unlock (&self->priv->__lock__queue);
 
204
                if (_inner_error_ != NULL) {
 
205
                        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);
 
206
                        g_clear_error (&_inner_error_);
 
207
                        return;
 
208
                }
 
209
        }
 
210
        sqlite3_mutex_leave (self->priv->_transaction_lock);
 
211
}
 
212
 
 
213
 
 
214
/**
 
215
     * {@inheritDoc}
 
216
     */
 
217
static gpointer _g_object_ref0 (gpointer self) {
 
218
        return self ? g_object_ref (self) : NULL;
 
219
}
 
220
 
 
221
 
 
222
static void sql_heavy_transaction_real_queue (SQLHeavyQueryable* base, SQLHeavyQuery* query, GError** error) {
 
223
        SQLHeavyTransaction * self;
 
224
        GError * _inner_error_ = NULL;
 
225
        self = (SQLHeavyTransaction*) base;
 
226
        g_return_if_fail (query != NULL);
 
227
        {
 
228
                SQLHeavyQuery* _tmp1_;
 
229
                GSequenceIter* _tmp2_ = NULL;
 
230
                g_static_rec_mutex_lock (&self->priv->__lock__queue);
 
231
                if (self->priv->_queue == NULL) {
 
232
                        GSequence* _tmp0_ = NULL;
 
233
                        _tmp0_ = g_sequence_new (g_object_unref);
 
234
                        _g_sequence_free0 (self->priv->_queue);
 
235
                        self->priv->_queue = _tmp0_;
 
236
                }
 
237
                _tmp1_ = _g_object_ref0 (query);
 
238
                _tmp2_ = g_sequence_append (self->priv->_queue, _tmp1_);
 
239
                __finally45:
 
240
                g_static_rec_mutex_unlock (&self->priv->__lock__queue);
 
241
                if (_inner_error_ != NULL) {
 
242
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
243
                                g_propagate_error (error, _inner_error_);
 
244
                                return;
 
245
                        } else {
 
246
                                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);
 
247
                                g_clear_error (&_inner_error_);
 
248
                                return;
 
249
                        }
 
250
                }
 
251
        }
 
252
}
 
253
 
 
254
 
 
255
/**
 
256
     * Resolve the transaction
 
257
     *
 
258
     * @param commit whether to commit the transaction or roll it back
 
259
     */
 
260
static void sql_heavy_transaction_resolve (SQLHeavyTransaction* self, gboolean commit, GError** error) {
 
261
        const gchar* _tmp1_ = NULL;
 
262
        gchar* _tmp2_ = NULL;
 
263
        gchar* _tmp3_;
 
264
        SQLHeavyQuery* _tmp4_ = NULL;
 
265
        SQLHeavyQuery* _tmp5_;
 
266
        SQLHeavyQuery* query;
 
267
        SQLHeavyTransactionStatus _tmp6_ = 0;
 
268
        GError * _inner_error_ = NULL;
 
269
        g_return_if_fail (self != NULL);
 
270
        if (self->priv->_status != SQL_HEAVY_TRANSACTION_STATUS_UNRESOLVED) {
 
271
                GError* _tmp0_ = NULL;
 
272
                _tmp0_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_TRANSACTION, "Refusing to resolve an already resolved transaction.");
 
273
                _inner_error_ = _tmp0_;
 
274
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
275
                        g_propagate_error (error, _inner_error_);
 
276
                        return;
 
277
                } else {
 
278
                        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);
 
279
                        g_clear_error (&_inner_error_);
 
280
                        return;
 
281
                }
 
282
        }
 
283
        if (commit) {
 
284
                _tmp1_ = "RELEASE";
 
285
        } else {
 
286
                _tmp1_ = "ROLLBACK TRANSACTION TO";
 
287
        }
 
288
        _tmp2_ = g_strdup_printf ("%s SAVEPOINT 'SQLHeavy-0x%x';", _tmp1_, (guint) self);
 
289
        _tmp3_ = _tmp2_;
 
290
        _tmp4_ = sql_heavy_queryable_prepare (self->priv->_parent, _tmp3_, &_inner_error_);
 
291
        _tmp5_ = _tmp4_;
 
292
        _g_free0 (_tmp3_);
 
293
        query = _tmp5_;
 
294
        if (_inner_error_ != NULL) {
 
295
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
296
                        g_propagate_error (error, _inner_error_);
 
297
                        return;
 
298
                } else {
 
299
                        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);
 
300
                        g_clear_error (&_inner_error_);
 
301
                        return;
 
302
                }
 
303
        }
 
304
        sql_heavy_queryable_queue (self->priv->_parent, query, &_inner_error_);
 
305
        if (_inner_error_ != NULL) {
 
306
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
307
                        g_propagate_error (error, _inner_error_);
 
308
                        _g_object_unref0 (query);
 
309
                        return;
 
310
                } else {
 
311
                        _g_object_unref0 (query);
 
312
                        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);
 
313
                        g_clear_error (&_inner_error_);
 
314
                        return;
 
315
                }
 
316
        }
 
317
        if (commit) {
 
318
                _tmp6_ = SQL_HEAVY_TRANSACTION_STATUS_COMMITTED;
 
319
        } else {
 
320
                _tmp6_ = SQL_HEAVY_TRANSACTION_STATUS_ROLLED_BACK;
 
321
        }
 
322
        sql_heavy_transaction_set_status (self, _tmp6_);
 
323
        sql_heavy_queryable_unlock (self->priv->_parent);
 
324
        g_signal_emit_by_name (self, "resolved", self->priv->_status);
 
325
        _g_object_unref0 (query);
 
326
}
 
327
 
 
328
 
 
329
static void sql_heavy_transaction_resolve_async_data_free (gpointer _data) {
 
330
        SqlHeavyTransactionResolveAsyncData* data;
 
331
        data = _data;
 
332
        _g_object_unref0 (data->self);
 
333
        g_slice_free (SqlHeavyTransactionResolveAsyncData, data);
 
334
}
 
335
 
 
336
 
 
337
static void sql_heavy_transaction_resolve_async (SQLHeavyTransaction* self, gboolean commit, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
338
        SqlHeavyTransactionResolveAsyncData* _data_;
 
339
        _data_ = g_slice_new0 (SqlHeavyTransactionResolveAsyncData);
 
340
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, sql_heavy_transaction_resolve_async);
 
341
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, sql_heavy_transaction_resolve_async_data_free);
 
342
        _data_->self = _g_object_ref0 (self);
 
343
        _data_->commit = commit;
 
344
        sql_heavy_transaction_resolve_async_co (_data_);
 
345
}
 
346
 
 
347
 
 
348
static void sql_heavy_transaction_resolve_finish (SQLHeavyTransaction* self, GAsyncResult* _res_, GError** error) {
 
349
        SqlHeavyTransactionResolveAsyncData* _data_;
 
350
        if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
 
351
                return;
 
352
        }
 
353
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
354
}
 
355
 
 
356
 
 
357
/**
 
358
     * Resolve the transaction asychronously
 
359
     *
 
360
     * @param commit whether to commit the transaction or roll it back
 
361
     */
 
362
static void sql_heavy_transaction_resolve_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
363
        SqlHeavyTransactionResolveAsyncData* data;
 
364
        data = _user_data_;
 
365
        data->_source_object_ = source_object;
 
366
        data->_res_ = _res_;
 
367
        sql_heavy_transaction_resolve_async_co (data);
 
368
}
 
369
 
 
370
 
 
371
static gboolean sql_heavy_transaction_resolve_async_co (SqlHeavyTransactionResolveAsyncData* data) {
 
372
        switch (data->_state_) {
 
373
                case 0:
 
374
                goto _state_0;
 
375
                case 1:
 
376
                goto _state_1;
 
377
                default:
 
378
                g_assert_not_reached ();
 
379
        }
 
380
        _state_0:
 
381
        if (data->self->priv->_status != SQL_HEAVY_TRANSACTION_STATUS_UNRESOLVED) {
 
382
                data->_tmp0_ = NULL;
 
383
                data->_tmp0_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_TRANSACTION, "Refusing to resolve an already resolved transaction.");
 
384
                data->_inner_error_ = data->_tmp0_;
 
385
                if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
 
386
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
387
                        g_error_free (data->_inner_error_);
 
388
                        if (data->_state_ == 0) {
 
389
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
390
                        } else {
 
391
                                g_simple_async_result_complete (data->_async_result);
 
392
                        }
 
393
                        g_object_unref (data->_async_result);
 
394
                        return FALSE;
 
395
                } else {
 
396
                        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);
 
397
                        g_clear_error (&data->_inner_error_);
 
398
                        return FALSE;
 
399
                }
 
400
        }
 
401
        if (data->commit) {
 
402
                data->_tmp1_ = "RELEASE";
 
403
        } else {
 
404
                data->_tmp1_ = "ROLLBACK TRANSACTION TO";
 
405
        }
 
406
        data->_tmp2_ = NULL;
 
407
        data->_tmp2_ = g_strdup_printf ("%s SAVEPOINT 'SQLHeavy-0x%x';", data->_tmp1_, (guint) data->self);
 
408
        data->_tmp3_ = data->_tmp2_;
 
409
        data->_tmp4_ = NULL;
 
410
        data->_tmp4_ = sql_heavy_queryable_prepare ((SQLHeavyQueryable*) data->self, data->_tmp3_, &data->_inner_error_);
 
411
        data->_tmp5_ = data->_tmp4_;
 
412
        _g_free0 (data->_tmp3_);
 
413
        data->query = data->_tmp5_;
 
414
        if (data->_inner_error_ != NULL) {
 
415
                if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
 
416
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
417
                        g_error_free (data->_inner_error_);
 
418
                        if (data->_state_ == 0) {
 
419
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
420
                        } else {
 
421
                                g_simple_async_result_complete (data->_async_result);
 
422
                        }
 
423
                        g_object_unref (data->_async_result);
 
424
                        return FALSE;
 
425
                } else {
 
426
                        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);
 
427
                        g_clear_error (&data->_inner_error_);
 
428
                        return FALSE;
 
429
                }
 
430
        }
 
431
        data->_state_ = 1;
 
432
        sql_heavy_query_execute_async (data->query, NULL, sql_heavy_transaction_resolve_async_ready, data);
 
433
        return FALSE;
 
434
        _state_1:
 
435
        data->_tmp6_ = NULL;
 
436
        data->_tmp6_ = sql_heavy_query_execute_finish (data->query, data->_res_, &data->_inner_error_);
 
437
        data->_tmp7_ = data->_tmp6_;
 
438
        _g_object_unref0 (data->_tmp7_);
 
439
        if (data->_inner_error_ != NULL) {
 
440
                if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
 
441
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
442
                        g_error_free (data->_inner_error_);
 
443
                        _g_object_unref0 (data->query);
 
444
                        if (data->_state_ == 0) {
 
445
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
446
                        } else {
 
447
                                g_simple_async_result_complete (data->_async_result);
 
448
                        }
 
449
                        g_object_unref (data->_async_result);
 
450
                        return FALSE;
 
451
                } else {
 
452
                        _g_object_unref0 (data->query);
 
453
                        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);
 
454
                        g_clear_error (&data->_inner_error_);
 
455
                        return FALSE;
 
456
                }
 
457
        }
 
458
        if (data->commit) {
 
459
                data->_tmp8_ = SQL_HEAVY_TRANSACTION_STATUS_COMMITTED;
 
460
        } else {
 
461
                data->_tmp8_ = SQL_HEAVY_TRANSACTION_STATUS_ROLLED_BACK;
 
462
        }
 
463
        sql_heavy_transaction_set_status (data->self, data->_tmp8_);
 
464
        sql_heavy_queryable_unlock (data->self->priv->_parent);
 
465
        g_signal_emit_by_name (data->self, "resolved", data->self->priv->_status);
 
466
        _g_object_unref0 (data->query);
 
467
        if (data->_state_ == 0) {
 
468
                g_simple_async_result_complete_in_idle (data->_async_result);
 
469
        } else {
 
470
                g_simple_async_result_complete (data->_async_result);
 
471
        }
 
472
        g_object_unref (data->_async_result);
 
473
        return FALSE;
 
474
}
 
475
 
 
476
 
 
477
/**
 
478
     * Commit the transaction to the database
 
479
     */
 
480
void sql_heavy_transaction_commit (SQLHeavyTransaction* self, GError** error) {
 
481
        GError * _inner_error_ = NULL;
 
482
        g_return_if_fail (self != NULL);
 
483
        sql_heavy_transaction_resolve (self, TRUE, &_inner_error_);
 
484
        if (_inner_error_ != NULL) {
 
485
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
486
                        g_propagate_error (error, _inner_error_);
 
487
                        return;
 
488
                } else {
 
489
                        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);
 
490
                        g_clear_error (&_inner_error_);
 
491
                        return;
 
492
                }
 
493
        }
 
494
}
 
495
 
 
496
 
 
497
static void sql_heavy_transaction_commit_async_data_free (gpointer _data) {
 
498
        SqlHeavyTransactionCommitAsyncData* data;
 
499
        data = _data;
 
500
        _g_object_unref0 (data->self);
 
501
        g_slice_free (SqlHeavyTransactionCommitAsyncData, data);
 
502
}
 
503
 
 
504
 
 
505
void sql_heavy_transaction_commit_async (SQLHeavyTransaction* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
506
        SqlHeavyTransactionCommitAsyncData* _data_;
 
507
        _data_ = g_slice_new0 (SqlHeavyTransactionCommitAsyncData);
 
508
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, sql_heavy_transaction_commit_async);
 
509
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, sql_heavy_transaction_commit_async_data_free);
 
510
        _data_->self = _g_object_ref0 (self);
 
511
        sql_heavy_transaction_commit_async_co (_data_);
 
512
}
 
513
 
 
514
 
 
515
void sql_heavy_transaction_commit_finish (SQLHeavyTransaction* self, GAsyncResult* _res_, GError** error) {
 
516
        SqlHeavyTransactionCommitAsyncData* _data_;
 
517
        if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
 
518
                return;
 
519
        }
 
520
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
521
}
 
522
 
 
523
 
 
524
/**
 
525
     * Commit the transaction to the database asynchronously
 
526
     */
 
527
static void sql_heavy_transaction_commit_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
528
        SqlHeavyTransactionCommitAsyncData* data;
 
529
        data = _user_data_;
 
530
        data->_source_object_ = source_object;
 
531
        data->_res_ = _res_;
 
532
        sql_heavy_transaction_commit_async_co (data);
 
533
}
 
534
 
 
535
 
 
536
static gboolean sql_heavy_transaction_commit_async_co (SqlHeavyTransactionCommitAsyncData* data) {
 
537
        switch (data->_state_) {
 
538
                case 0:
 
539
                goto _state_0;
 
540
                case 1:
 
541
                goto _state_1;
 
542
                default:
 
543
                g_assert_not_reached ();
 
544
        }
 
545
        _state_0:
 
546
        data->_state_ = 1;
 
547
        sql_heavy_transaction_resolve_async (data->self, TRUE, sql_heavy_transaction_commit_async_ready, data);
 
548
        return FALSE;
 
549
        _state_1:
 
550
        sql_heavy_transaction_resolve_finish (data->self, data->_res_, &data->_inner_error_);
 
551
        if (data->_inner_error_ != NULL) {
 
552
                if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
 
553
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
554
                        g_error_free (data->_inner_error_);
 
555
                        if (data->_state_ == 0) {
 
556
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
557
                        } else {
 
558
                                g_simple_async_result_complete (data->_async_result);
 
559
                        }
 
560
                        g_object_unref (data->_async_result);
 
561
                        return FALSE;
 
562
                } else {
 
563
                        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);
 
564
                        g_clear_error (&data->_inner_error_);
 
565
                        return FALSE;
 
566
                }
 
567
        }
 
568
        if (data->_state_ == 0) {
 
569
                g_simple_async_result_complete_in_idle (data->_async_result);
 
570
        } else {
 
571
                g_simple_async_result_complete (data->_async_result);
 
572
        }
 
573
        g_object_unref (data->_async_result);
 
574
        return FALSE;
 
575
}
 
576
 
 
577
 
 
578
/**
 
579
     * Rollback the transaction
 
580
     */
 
581
void sql_heavy_transaction_rollback (SQLHeavyTransaction* self, GError** error) {
 
582
        GError * _inner_error_ = NULL;
 
583
        g_return_if_fail (self != NULL);
 
584
        sql_heavy_transaction_resolve (self, FALSE, &_inner_error_);
 
585
        if (_inner_error_ != NULL) {
 
586
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
587
                        g_propagate_error (error, _inner_error_);
 
588
                        return;
 
589
                } else {
 
590
                        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);
 
591
                        g_clear_error (&_inner_error_);
 
592
                        return;
 
593
                }
 
594
        }
 
595
}
 
596
 
 
597
 
 
598
static void sql_heavy_transaction_rollback_async_data_free (gpointer _data) {
 
599
        SqlHeavyTransactionRollbackAsyncData* data;
 
600
        data = _data;
 
601
        _g_object_unref0 (data->self);
 
602
        g_slice_free (SqlHeavyTransactionRollbackAsyncData, data);
 
603
}
 
604
 
 
605
 
 
606
void sql_heavy_transaction_rollback_async (SQLHeavyTransaction* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
607
        SqlHeavyTransactionRollbackAsyncData* _data_;
 
608
        _data_ = g_slice_new0 (SqlHeavyTransactionRollbackAsyncData);
 
609
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, sql_heavy_transaction_rollback_async);
 
610
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, sql_heavy_transaction_rollback_async_data_free);
 
611
        _data_->self = _g_object_ref0 (self);
 
612
        sql_heavy_transaction_rollback_async_co (_data_);
 
613
}
 
614
 
 
615
 
 
616
void sql_heavy_transaction_rollback_finish (SQLHeavyTransaction* self, GAsyncResult* _res_, GError** error) {
 
617
        SqlHeavyTransactionRollbackAsyncData* _data_;
 
618
        if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
 
619
                return;
 
620
        }
 
621
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
622
}
 
623
 
 
624
 
 
625
/**
 
626
     * Rollback the transaction asynchronously
 
627
     */
 
628
static void sql_heavy_transaction_rollback_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
629
        SqlHeavyTransactionRollbackAsyncData* data;
 
630
        data = _user_data_;
 
631
        data->_source_object_ = source_object;
 
632
        data->_res_ = _res_;
 
633
        sql_heavy_transaction_rollback_async_co (data);
 
634
}
 
635
 
 
636
 
 
637
static gboolean sql_heavy_transaction_rollback_async_co (SqlHeavyTransactionRollbackAsyncData* data) {
 
638
        switch (data->_state_) {
 
639
                case 0:
 
640
                goto _state_0;
 
641
                case 1:
 
642
                goto _state_1;
 
643
                default:
 
644
                g_assert_not_reached ();
 
645
        }
 
646
        _state_0:
 
647
        data->_state_ = 1;
 
648
        sql_heavy_transaction_resolve_async (data->self, FALSE, sql_heavy_transaction_rollback_async_ready, data);
 
649
        return FALSE;
 
650
        _state_1:
 
651
        sql_heavy_transaction_resolve_finish (data->self, data->_res_, &data->_inner_error_);
 
652
        if (data->_inner_error_ != NULL) {
 
653
                if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
 
654
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
655
                        g_error_free (data->_inner_error_);
 
656
                        if (data->_state_ == 0) {
 
657
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
658
                        } else {
 
659
                                g_simple_async_result_complete (data->_async_result);
 
660
                        }
 
661
                        g_object_unref (data->_async_result);
 
662
                        return FALSE;
 
663
                } else {
 
664
                        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);
 
665
                        g_clear_error (&data->_inner_error_);
 
666
                        return FALSE;
 
667
                }
 
668
        }
 
669
        if (data->_state_ == 0) {
 
670
                g_simple_async_result_complete_in_idle (data->_async_result);
 
671
        } else {
 
672
                g_simple_async_result_complete (data->_async_result);
 
673
        }
 
674
        g_object_unref (data->_async_result);
 
675
        return FALSE;
 
676
}
 
677
 
 
678
 
 
679
/**
 
680
     * Create a new transaction.
 
681
     *
 
682
     * @param parent The queryable to create the transaction on top of
 
683
     */
 
684
static gpointer _g_error_copy0 (gpointer self) {
 
685
        return self ? g_error_copy (self) : NULL;
 
686
}
 
687
 
 
688
 
 
689
SQLHeavyTransaction* sql_heavy_transaction_construct (GType object_type, SQLHeavyQueryable* parent, GError** error) {
 
690
        SQLHeavyTransaction * self = NULL;
 
691
        GError * _inner_error_ = NULL;
 
692
        g_return_val_if_fail (parent != NULL, NULL);
 
693
        self = (SQLHeavyTransaction*) g_object_new (object_type, "parent", parent, NULL);
 
694
        if (self->priv->err != NULL) {
 
695
                GError* _tmp0_;
 
696
                _tmp0_ = _g_error_copy0 (self->priv->err);
 
697
                _inner_error_ = _tmp0_;
 
698
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
699
                        g_propagate_error (error, _inner_error_);
 
700
                        _g_object_unref0 (self);
 
701
                        return NULL;
 
702
                } else {
 
703
                        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);
 
704
                        g_clear_error (&_inner_error_);
 
705
                        return NULL;
 
706
                }
 
707
        }
 
708
        return self;
 
709
}
 
710
 
 
711
 
 
712
SQLHeavyTransaction* sql_heavy_transaction_new (SQLHeavyQueryable* parent, GError** error) {
 
713
        return sql_heavy_transaction_construct (SQL_HEAVY_TYPE_TRANSACTION, parent, error);
 
714
}
 
715
 
 
716
 
 
717
SQLHeavyTransactionStatus sql_heavy_transaction_get_status (SQLHeavyTransaction* self) {
 
718
        SQLHeavyTransactionStatus result;
 
719
        g_return_val_if_fail (self != NULL, 0);
 
720
        result = self->priv->_status;
 
721
        return result;
 
722
}
 
723
 
 
724
 
 
725
static void sql_heavy_transaction_set_status (SQLHeavyTransaction* self, SQLHeavyTransactionStatus value) {
 
726
        g_return_if_fail (self != NULL);
 
727
        self->priv->_status = value;
 
728
        g_object_notify ((GObject *) self, "status");
 
729
}
 
730
 
 
731
 
 
732
SQLHeavyQueryable* sql_heavy_transaction_get_parent (SQLHeavyTransaction* self) {
 
733
        SQLHeavyQueryable* result;
 
734
        g_return_val_if_fail (self != NULL, NULL);
 
735
        result = self->priv->_parent;
 
736
        return result;
 
737
}
 
738
 
 
739
 
 
740
static void sql_heavy_transaction_set_parent (SQLHeavyTransaction* self, SQLHeavyQueryable* value) {
 
741
        SQLHeavyQueryable* _tmp0_;
 
742
        g_return_if_fail (self != NULL);
 
743
        _tmp0_ = _g_object_ref0 (value);
 
744
        _g_object_unref0 (self->priv->_parent);
 
745
        self->priv->_parent = _tmp0_;
 
746
        g_object_notify ((GObject *) self, "parent");
 
747
}
 
748
 
 
749
 
 
750
static SQLHeavyDatabase* sql_heavy_transaction_real_get_database (SQLHeavyQueryable* base) {
 
751
        SQLHeavyDatabase* result;
 
752
        SQLHeavyTransaction* self;
 
753
        SQLHeavyDatabase* _tmp0_ = NULL;
 
754
        self = (SQLHeavyTransaction*) base;
 
755
        _tmp0_ = sql_heavy_queryable_get_database (self->priv->_parent);
 
756
        result = _tmp0_;
 
757
        return result;
 
758
}
 
759
 
 
760
 
 
761
static GObject * sql_heavy_transaction_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 
762
        GObject * obj;
 
763
        GObjectClass * parent_class;
 
764
        SQLHeavyTransaction * self;
 
765
        gchar* _tmp0_ = NULL;
 
766
        gchar* _tmp1_;
 
767
        SQLHeavyQuery* _tmp2_ = NULL;
 
768
        SQLHeavyQuery* _tmp3_;
 
769
        SQLHeavyQuery* _tmp4_;
 
770
        SQLHeavyQuery* _tmp5_;
 
771
        SQLHeavyQueryResult* _tmp6_ = NULL;
 
772
        SQLHeavyQueryResult* _tmp7_;
 
773
        GError * _inner_error_ = NULL;
 
774
        parent_class = G_OBJECT_CLASS (sql_heavy_transaction_parent_class);
 
775
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 
776
        self = SQL_HEAVY_TRANSACTION (obj);
 
777
        sql_heavy_queryable_lock (self->priv->_parent);
 
778
        _tmp0_ = g_strdup_printf ("SAVEPOINT 'SQLHeavy-0x%x';", (guint) self);
 
779
        _tmp1_ = _tmp0_;
 
780
        _tmp2_ = sql_heavy_queryable_prepare ((SQLHeavyQueryable*) self, _tmp1_, &_inner_error_);
 
781
        _tmp3_ = _tmp2_;
 
782
        _g_free0 (_tmp1_);
 
783
        _tmp4_ = _tmp3_;
 
784
        if (_inner_error_ != NULL) {
 
785
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
786
                        goto __catch46_sql_heavy_error;
 
787
                }
 
788
                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);
 
789
                g_clear_error (&_inner_error_);
 
790
        }
 
791
        _tmp5_ = _tmp4_;
 
792
        _tmp6_ = sql_heavy_query_execute (_tmp5_, NULL, &_inner_error_, NULL);
 
793
        _tmp7_ = _tmp6_;
 
794
        _g_object_unref0 (_tmp7_);
 
795
        _g_object_unref0 (_tmp5_);
 
796
        if (_inner_error_ != NULL) {
 
797
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
798
                        goto __catch46_sql_heavy_error;
 
799
                }
 
800
                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);
 
801
                g_clear_error (&_inner_error_);
 
802
        }
 
803
        goto __finally46;
 
804
        __catch46_sql_heavy_error:
 
805
        {
 
806
                GError * e;
 
807
                GError* _tmp8_;
 
808
                e = _inner_error_;
 
809
                _inner_error_ = NULL;
 
810
                _tmp8_ = _g_error_copy0 (e);
 
811
                _g_error_free0 (self->priv->err);
 
812
                self->priv->err = _tmp8_;
 
813
                g_critical ("sqlheavy-transaction.vala:160: Unable to create transaction: %s (%d)", e->message, e->code);
 
814
                sql_heavy_queryable_unlock (self->priv->_parent);
 
815
                _g_error_free0 (e);
 
816
        }
 
817
        __finally46:
 
818
        if (_inner_error_ != NULL) {
 
819
                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);
 
820
                g_clear_error (&_inner_error_);
 
821
        }
 
822
        return obj;
 
823
}
 
824
 
 
825
 
 
826
static void sql_heavy_transaction_class_init (SQLHeavyTransactionClass * klass) {
 
827
        sql_heavy_transaction_parent_class = g_type_class_peek_parent (klass);
 
828
        g_type_class_add_private (klass, sizeof (SQLHeavyTransactionPrivate));
 
829
        G_OBJECT_CLASS (klass)->get_property = _vala_sql_heavy_transaction_get_property;
 
830
        G_OBJECT_CLASS (klass)->set_property = _vala_sql_heavy_transaction_set_property;
 
831
        G_OBJECT_CLASS (klass)->constructor = sql_heavy_transaction_constructor;
 
832
        G_OBJECT_CLASS (klass)->finalize = sql_heavy_transaction_finalize;
 
833
        /**
 
834
             * Status of the transaction.
 
835
             */
 
836
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TRANSACTION_STATUS, g_param_spec_enum ("status", "status", "status", SQL_HEAVY_TYPE_TRANSACTION_STATUS, SQL_HEAVY_TRANSACTION_STATUS_UNRESOLVED, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 
837
        /**
 
838
             * Parent querayble
 
839
             */
 
840
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TRANSACTION_PARENT, g_param_spec_object ("parent", "parent", "parent", SQL_HEAVY_TYPE_QUERYABLE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 
841
        /**
 
842
             * {@inheritDoc}
 
843
             */
 
844
        g_object_class_override_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TRANSACTION_DATABASE, "database");
 
845
        /**
 
846
             * The transaction has been resolved (committed or rolled back)
 
847
             *
 
848
             * @param status whether the transaction was committed or rolled back
 
849
             */
 
850
        g_signal_new ("resolved", SQL_HEAVY_TYPE_TRANSACTION, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__ENUM, G_TYPE_NONE, 1, SQL_HEAVY_TYPE_TRANSACTION_STATUS);
 
851
}
 
852
 
 
853
 
 
854
static void sql_heavy_transaction_sql_heavy_queryable_interface_init (SQLHeavyQueryableIface * iface) {
 
855
        sql_heavy_transaction_sql_heavy_queryable_parent_iface = g_type_interface_peek_parent (iface);
 
856
        iface->lock = (void (*)(SQLHeavyQueryable*)) sql_heavy_transaction_real_lock;
 
857
        iface->unlock = (void (*)(SQLHeavyQueryable*)) sql_heavy_transaction_real_unlock;
 
858
        iface->queue = (void (*)(SQLHeavyQueryable* ,SQLHeavyQuery* ,GError**)) sql_heavy_transaction_real_queue;
 
859
        iface->get_database = sql_heavy_transaction_real_get_database;
 
860
}
 
861
 
 
862
 
 
863
static void sql_heavy_transaction_instance_init (SQLHeavyTransaction * self) {
 
864
        sqlite3_mutex* _tmp0_ = NULL;
 
865
        self->priv = SQL_HEAVY_TRANSACTION_GET_PRIVATE (self);
 
866
        self->priv->_status = SQL_HEAVY_TRANSACTION_STATUS_UNRESOLVED;
 
867
        _tmp0_ = sqlite3_mutex_alloc (SQLITE_MUTEX_FAST);
 
868
        self->priv->_transaction_lock = _tmp0_;
 
869
        g_static_rec_mutex_init (&self->priv->__lock__queue);
 
870
        self->priv->_queue = NULL;
 
871
        self->priv->err = NULL;
 
872
}
 
873
 
 
874
 
 
875
static void sql_heavy_transaction_finalize (GObject* obj) {
 
876
        SQLHeavyTransaction * self;
 
877
        GError * _inner_error_ = NULL;
 
878
        self = SQL_HEAVY_TRANSACTION (obj);
 
879
        if (self->priv->_status == SQL_HEAVY_TRANSACTION_STATUS_UNRESOLVED) {
 
880
                sql_heavy_transaction_rollback (self, &_inner_error_);
 
881
                if (_inner_error_ != NULL) {
 
882
                        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);
 
883
                        g_clear_error (&_inner_error_);
 
884
                }
 
885
        }
 
886
        _g_object_unref0 (self->priv->_parent);
 
887
        _sqlite3_mutex_free0 (self->priv->_transaction_lock);
 
888
        g_static_rec_mutex_free (&self->priv->__lock__queue);
 
889
        _g_sequence_free0 (self->priv->_queue);
 
890
        _g_error_free0 (self->priv->err);
 
891
        G_OBJECT_CLASS (sql_heavy_transaction_parent_class)->finalize (obj);
 
892
}
 
893
 
 
894
 
 
895
/**
 
896
   * Object representing an SQLite transaction
 
897
   *
 
898
   * Note that this is implemented using SQLite's
 
899
   * [[http://sqlite.org/lang_savepoint.html|SAVEPOINT]] feature,
 
900
   * meaning that by default it is like that of a
 
901
   * {@link TransactionType.DEFERRED} transaction. This behaviour may
 
902
   * be modified by first manually running a
 
903
   * [[http://sqlite.org/lang_transaction.html|transaction]] in SQL,
 
904
   * but remember that such transactions cannot be nested.
 
905
   */
 
906
GType sql_heavy_transaction_get_type (void) {
 
907
        static volatile gsize sql_heavy_transaction_type_id__volatile = 0;
 
908
        if (g_once_init_enter (&sql_heavy_transaction_type_id__volatile)) {
 
909
                static const GTypeInfo g_define_type_info = { sizeof (SQLHeavyTransactionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) sql_heavy_transaction_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SQLHeavyTransaction), 0, (GInstanceInitFunc) sql_heavy_transaction_instance_init, NULL };
 
910
                static const GInterfaceInfo sql_heavy_queryable_info = { (GInterfaceInitFunc) sql_heavy_transaction_sql_heavy_queryable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
911
                GType sql_heavy_transaction_type_id;
 
912
                sql_heavy_transaction_type_id = g_type_register_static (G_TYPE_OBJECT, "SQLHeavyTransaction", &g_define_type_info, 0);
 
913
                g_type_add_interface_static (sql_heavy_transaction_type_id, SQL_HEAVY_TYPE_QUERYABLE, &sql_heavy_queryable_info);
 
914
                g_once_init_leave (&sql_heavy_transaction_type_id__volatile, sql_heavy_transaction_type_id);
 
915
        }
 
916
        return sql_heavy_transaction_type_id__volatile;
 
917
}
 
918
 
 
919
 
 
920
static void _vala_sql_heavy_transaction_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
921
        SQLHeavyTransaction * self;
 
922
        self = SQL_HEAVY_TRANSACTION (object);
 
923
        switch (property_id) {
 
924
                case SQL_HEAVY_TRANSACTION_STATUS:
 
925
                g_value_set_enum (value, sql_heavy_transaction_get_status (self));
 
926
                break;
 
927
                case SQL_HEAVY_TRANSACTION_PARENT:
 
928
                g_value_set_object (value, sql_heavy_transaction_get_parent (self));
 
929
                break;
 
930
                case SQL_HEAVY_TRANSACTION_DATABASE:
 
931
                g_value_take_object (value, sql_heavy_queryable_get_database ((SQLHeavyQueryable*) self));
 
932
                break;
 
933
                default:
 
934
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
935
                break;
 
936
        }
 
937
}
 
938
 
 
939
 
 
940
static void _vala_sql_heavy_transaction_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
941
        SQLHeavyTransaction * self;
 
942
        self = SQL_HEAVY_TRANSACTION (object);
 
943
        switch (property_id) {
 
944
                case SQL_HEAVY_TRANSACTION_STATUS:
 
945
                sql_heavy_transaction_set_status (self, g_value_get_enum (value));
 
946
                break;
 
947
                case SQL_HEAVY_TRANSACTION_PARENT:
 
948
                sql_heavy_transaction_set_parent (self, g_value_get_object (value));
 
949
                break;
 
950
                default:
 
951
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
952
                break;
 
953
        }
 
954
}
 
955
 
 
956
 
 
957