← Back to branch summary

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

« back to all changes in this revision

Viewing changes to sqlheavy/sqlheavy-table-cursor.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-table-cursor.c
 
1
/* sqlheavy-table-cursor.c generated by valac 0.12.1, the Vala compiler
 
2
 * generated from sqlheavy-table-cursor.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include "SQLHeavy.h"
 
8
#include <stdlib.h>
 
9
#include <string.h>
 
10
#include <sqlite3.h>
 
11
 
 
12
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
13
#define _g_free0(var) (var = (g_free (var), NULL))
 
14
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
15
 
 
16
struct _SQLHeavyTableCursorPrivate {
 
17
        SQLHeavyTable* _table;
 
18
        gint64 _offset;
 
19
        SQLHeavySortOrder _sort_order;
 
20
        gchar* _sort_column;
 
21
        gint64 current_id;
 
22
        SQLHeavyQuery* _query;
 
23
};
 
24
 
 
25
 
 
26
static gpointer sql_heavy_table_cursor_parent_class = NULL;
 
27
static SQLHeavyRecordSetIface* sql_heavy_table_cursor_sql_heavy_record_set_parent_iface = NULL;
 
28
static SQLHeavyCursorIface* sql_heavy_table_cursor_sql_heavy_cursor_parent_iface = NULL;
 
29
 
 
30
#define SQL_HEAVY_TABLE_CURSOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SQL_HEAVY_TYPE_TABLE_CURSOR, SQLHeavyTableCursorPrivate))
 
31
enum  {
 
32
        SQL_HEAVY_TABLE_CURSOR_DUMMY_PROPERTY,
 
33
        SQL_HEAVY_TABLE_CURSOR_TABLE,
 
34
        SQL_HEAVY_TABLE_CURSOR_OFFSET,
 
35
        SQL_HEAVY_TABLE_CURSOR_SORT_ORDER,
 
36
        SQL_HEAVY_TABLE_CURSOR_SORT_COLUMN,
 
37
        SQL_HEAVY_TABLE_CURSOR_FIELD_COUNT
 
38
};
 
39
static SQLHeavyRecord* sql_heavy_table_cursor_real_get (SQLHeavyCursor* base, GError** error);
 
40
const gchar* sql_heavy_sqlite_errstr (gint ec);
 
41
static gboolean sql_heavy_table_cursor_move_to_internal (SQLHeavyTableCursor* self, gint64 offset);
 
42
static SQLHeavyQuery* sql_heavy_table_cursor_get_query (SQLHeavyTableCursor* self);
 
43
static void sql_heavy_table_cursor_set_offset (SQLHeavyTableCursor* self, gint64 value);
 
44
static gboolean sql_heavy_table_cursor_real_move_to (SQLHeavyCursor* base, gint64 offset, GError** error);
 
45
static gboolean sql_heavy_table_cursor_real_next (SQLHeavyRecordSet* base, GError** error);
 
46
static gboolean sql_heavy_table_cursor_real_previous (SQLHeavyCursor* base, GError** error);
 
47
static GObject * sql_heavy_table_cursor_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 
48
static void sql_heavy_table_cursor_finalize (GObject* obj);
 
49
static void _vala_sql_heavy_table_cursor_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
50
static void _vala_sql_heavy_table_cursor_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
51
 
 
52
 
 
53
/**
 
54
     * {@inheritDoc}
 
55
     */
 
56
static SQLHeavyRecord* sql_heavy_table_cursor_real_get (SQLHeavyCursor* base, GError** error) {
 
57
        SQLHeavyTableCursor * self;
 
58
        SQLHeavyRecord* result = NULL;
 
59
        SQLHeavyRow* _tmp2_ = NULL;
 
60
        GError * _inner_error_ = NULL;
 
61
        self = (SQLHeavyTableCursor*) base;
 
62
        if (self->priv->current_id <= 0) {
 
63
                const gchar* _tmp0_ = NULL;
 
64
                GError* _tmp1_ = NULL;
 
65
                _tmp0_ = sql_heavy_sqlite_errstr (SQLITE_RANGE);
 
66
                _tmp1_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_RANGE, _tmp0_);
 
67
                _inner_error_ = _tmp1_;
 
68
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
69
                        g_propagate_error (error, _inner_error_);
 
70
                        return NULL;
 
71
                } else {
 
72
                        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);
 
73
                        g_clear_error (&_inner_error_);
 
74
                        return NULL;
 
75
                }
 
76
        }
 
77
        _tmp2_ = sql_heavy_row_new (self->priv->_table, self->priv->current_id);
 
78
        result = (SQLHeavyRecord*) _tmp2_;
 
79
        return result;
 
80
}
 
81
 
 
82
 
 
83
static gpointer _g_object_ref0 (gpointer self) {
 
84
        return self ? g_object_ref (self) : NULL;
 
85
}
 
86
 
 
87
 
 
88
static gboolean sql_heavy_table_cursor_move_to_internal (SQLHeavyTableCursor* self, gint64 offset) {
 
89
        gboolean result = FALSE;
 
90
        gint64 id;
 
91
        SQLHeavyQuery* _tmp0_ = NULL;
 
92
        SQLHeavyQuery* _tmp1_;
 
93
        SQLHeavyQuery* q;
 
94
        SQLHeavyQueryResult* _tmp2_ = NULL;
 
95
        SQLHeavyQueryResult* res;
 
96
        gint64 _tmp3_ = 0LL;
 
97
        gboolean _tmp4_;
 
98
        GError * _inner_error_ = NULL;
 
99
        g_return_val_if_fail (self != NULL, FALSE);
 
100
        id = (gint64) (-1);
 
101
        _tmp0_ = sql_heavy_table_cursor_get_query (self);
 
102
        _tmp1_ = _g_object_ref0 (_tmp0_);
 
103
        q = _tmp1_;
 
104
        sql_heavy_query_set_int64 (q, ":offset", offset, &_inner_error_);
 
105
        if (_inner_error_ != NULL) {
 
106
                _g_object_unref0 (q);
 
107
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
108
                        goto __catch40_sql_heavy_error;
 
109
                }
 
110
                _g_object_unref0 (q);
 
111
                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);
 
112
                g_clear_error (&_inner_error_);
 
113
                return FALSE;
 
114
        }
 
115
        _tmp2_ = sql_heavy_query_execute (q, NULL, &_inner_error_, NULL);
 
116
        res = _tmp2_;
 
117
        if (_inner_error_ != NULL) {
 
118
                _g_object_unref0 (q);
 
119
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
120
                        goto __catch40_sql_heavy_error;
 
121
                }
 
122
                _g_object_unref0 (q);
 
123
                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);
 
124
                g_clear_error (&_inner_error_);
 
125
                return FALSE;
 
126
        }
 
127
        _tmp4_ = sql_heavy_query_result_get_finished (res);
 
128
        if (_tmp4_) {
 
129
                _tmp3_ = (gint64) (-1);
 
130
        } else {
 
131
                gint64 _tmp5_;
 
132
                _tmp5_ = sql_heavy_record_fetch_int64 ((SQLHeavyRecord*) res, 0, &_inner_error_);
 
133
                _tmp3_ = _tmp5_;
 
134
                if (_inner_error_ != NULL) {
 
135
                        _g_object_unref0 (res);
 
136
                        _g_object_unref0 (q);
 
137
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
138
                                goto __catch40_sql_heavy_error;
 
139
                        }
 
140
                        _g_object_unref0 (res);
 
141
                        _g_object_unref0 (q);
 
142
                        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);
 
143
                        g_clear_error (&_inner_error_);
 
144
                        return FALSE;
 
145
                }
 
146
        }
 
147
        id = _tmp3_;
 
148
        _g_object_unref0 (res);
 
149
        _g_object_unref0 (q);
 
150
        goto __finally40;
 
151
        __catch40_sql_heavy_error:
 
152
        {
 
153
                GError * e;
 
154
                e = _inner_error_;
 
155
                _inner_error_ = NULL;
 
156
                g_critical ("sqlheavy-table-cursor.vala:67: Unable to move cursor: %s", e->message);
 
157
                result = FALSE;
 
158
                _g_error_free0 (e);
 
159
                return result;
 
160
        }
 
161
        __finally40:
 
162
        if (_inner_error_ != NULL) {
 
163
                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);
 
164
                g_clear_error (&_inner_error_);
 
165
                return FALSE;
 
166
        }
 
167
        if (id > 0) {
 
168
                g_debug ("sqlheavy-table-cursor.vala:72: Offset: %lld", offset);
 
169
                self->priv->current_id = id;
 
170
                sql_heavy_table_cursor_set_offset (self, offset);
 
171
                result = TRUE;
 
172
                return result;
 
173
        } else {
 
174
                result = FALSE;
 
175
                return result;
 
176
        }
 
177
}
 
178
 
 
179
 
 
180
/**
 
181
     * {@inheritDoc}
 
182
     */
 
183
static gboolean sql_heavy_table_cursor_real_move_to (SQLHeavyCursor* base, gint64 offset, GError** error) {
 
184
        SQLHeavyTableCursor * self;
 
185
        gboolean result = FALSE;
 
186
        gboolean _tmp0_;
 
187
        GError * _inner_error_ = NULL;
 
188
        self = (SQLHeavyTableCursor*) base;
 
189
        _tmp0_ = sql_heavy_table_cursor_move_to_internal (self, offset);
 
190
        if (!_tmp0_) {
 
191
                const gchar* _tmp1_ = NULL;
 
192
                GError* _tmp2_ = NULL;
 
193
                _tmp1_ = sql_heavy_sqlite_errstr (SQLITE_RANGE);
 
194
                _tmp2_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_RANGE, _tmp1_);
 
195
                _inner_error_ = _tmp2_;
 
196
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
197
                        g_propagate_error (error, _inner_error_);
 
198
                        return FALSE;
 
199
                } else {
 
200
                        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);
 
201
                        g_clear_error (&_inner_error_);
 
202
                        return FALSE;
 
203
                }
 
204
        }
 
205
        result = TRUE;
 
206
        return result;
 
207
}
 
208
 
 
209
 
 
210
/**
 
211
     * {@inheritDoc}
 
212
     */
 
213
static gboolean sql_heavy_table_cursor_real_next (SQLHeavyRecordSet* base, GError** error) {
 
214
        SQLHeavyTableCursor * self;
 
215
        gboolean result = FALSE;
 
216
        gboolean _tmp0_;
 
217
        self = (SQLHeavyTableCursor*) base;
 
218
        _tmp0_ = sql_heavy_table_cursor_move_to_internal (self, self->priv->_offset + 1);
 
219
        result = _tmp0_;
 
220
        return result;
 
221
}
 
222
 
 
223
 
 
224
/**
 
225
     * {@inheritDoc}
 
226
     */
 
227
static gboolean sql_heavy_table_cursor_real_previous (SQLHeavyCursor* base, GError** error) {
 
228
        SQLHeavyTableCursor * self;
 
229
        gboolean result = FALSE;
 
230
        gboolean _tmp0_;
 
231
        self = (SQLHeavyTableCursor*) base;
 
232
        _tmp0_ = sql_heavy_table_cursor_move_to_internal (self, self->priv->_offset - 1);
 
233
        result = _tmp0_;
 
234
        return result;
 
235
}
 
236
 
 
237
 
 
238
/**
 
239
     * Create a new cursor for the table
 
240
     *
 
241
     * @param table the table to create the cursor for
 
242
     */
 
243
SQLHeavyTableCursor* sql_heavy_table_cursor_construct (GType object_type, SQLHeavyTable* table) {
 
244
        SQLHeavyTableCursor * self = NULL;
 
245
        g_return_val_if_fail (table != NULL, NULL);
 
246
        self = (SQLHeavyTableCursor*) g_object_new (object_type, "table", table, NULL);
 
247
        return self;
 
248
}
 
249
 
 
250
 
 
251
SQLHeavyTableCursor* sql_heavy_table_cursor_new (SQLHeavyTable* table) {
 
252
        return sql_heavy_table_cursor_construct (SQL_HEAVY_TYPE_TABLE_CURSOR, table);
 
253
}
 
254
 
 
255
 
 
256
SQLHeavyTable* sql_heavy_table_cursor_get_table (SQLHeavyTableCursor* self) {
 
257
        SQLHeavyTable* result;
 
258
        g_return_val_if_fail (self != NULL, NULL);
 
259
        result = self->priv->_table;
 
260
        return result;
 
261
}
 
262
 
 
263
 
 
264
static void sql_heavy_table_cursor_set_table (SQLHeavyTableCursor* self, SQLHeavyTable* value) {
 
265
        SQLHeavyTable* _tmp0_;
 
266
        g_return_if_fail (self != NULL);
 
267
        _tmp0_ = _g_object_ref0 (value);
 
268
        _g_object_unref0 (self->priv->_table);
 
269
        self->priv->_table = _tmp0_;
 
270
        g_object_notify ((GObject *) self, "table");
 
271
}
 
272
 
 
273
 
 
274
gint64 sql_heavy_table_cursor_get_offset (SQLHeavyTableCursor* self) {
 
275
        gint64 result;
 
276
        g_return_val_if_fail (self != NULL, 0LL);
 
277
        result = self->priv->_offset;
 
278
        return result;
 
279
}
 
280
 
 
281
 
 
282
static void sql_heavy_table_cursor_set_offset (SQLHeavyTableCursor* self, gint64 value) {
 
283
        g_return_if_fail (self != NULL);
 
284
        self->priv->_offset = value;
 
285
        g_object_notify ((GObject *) self, "offset");
 
286
}
 
287
 
 
288
 
 
289
SQLHeavySortOrder sql_heavy_table_cursor_get_sort_order (SQLHeavyTableCursor* self) {
 
290
        SQLHeavySortOrder result;
 
291
        g_return_val_if_fail (self != NULL, 0);
 
292
        result = self->priv->_sort_order;
 
293
        return result;
 
294
}
 
295
 
 
296
 
 
297
void sql_heavy_table_cursor_set_sort_order (SQLHeavyTableCursor* self, SQLHeavySortOrder value) {
 
298
        g_return_if_fail (self != NULL);
 
299
        self->priv->_sort_order = value;
 
300
        g_object_notify ((GObject *) self, "sort-order");
 
301
}
 
302
 
 
303
 
 
304
const gchar* sql_heavy_table_cursor_get_sort_column (SQLHeavyTableCursor* self) {
 
305
        const gchar* result;
 
306
        g_return_val_if_fail (self != NULL, NULL);
 
307
        result = self->priv->_sort_column;
 
308
        return result;
 
309
}
 
310
 
 
311
 
 
312
void sql_heavy_table_cursor_set_sort_column (SQLHeavyTableCursor* self, const gchar* value) {
 
313
        gchar* _tmp0_;
 
314
        g_return_if_fail (self != NULL);
 
315
        _tmp0_ = g_strdup (value);
 
316
        _g_free0 (self->priv->_sort_column);
 
317
        self->priv->_sort_column = _tmp0_;
 
318
        g_object_notify ((GObject *) self, "sort-column");
 
319
}
 
320
 
 
321
 
 
322
gint sql_heavy_table_cursor_get_field_count (SQLHeavyTableCursor* self) {
 
323
        gint result;
 
324
        gint _tmp0_;
 
325
        g_return_val_if_fail (self != NULL, 0);
 
326
        _tmp0_ = sql_heavy_table_get_field_count (self->priv->_table);
 
327
        result = _tmp0_;
 
328
        return result;
 
329
}
 
330
 
 
331
 
 
332
static SQLHeavyQuery* sql_heavy_table_cursor_get_query (SQLHeavyTableCursor* self) {
 
333
        SQLHeavyQuery* result;
 
334
        GError * _inner_error_ = NULL;
 
335
        g_return_val_if_fail (self != NULL, NULL);
 
336
        if (self->priv->_query == NULL) {
 
337
                const gchar* _tmp0_ = NULL;
 
338
                SQLHeavyQueryable* _tmp1_ = NULL;
 
339
                const gchar* _tmp2_ = NULL;
 
340
                gchar* _tmp3_ = NULL;
 
341
                gchar* _tmp4_;
 
342
                gchar* _tmp5_;
 
343
                gchar* _tmp6_;
 
344
                gchar* _tmp7_;
 
345
                gchar* _tmp8_;
 
346
                gchar* _tmp9_ = NULL;
 
347
                gchar* _tmp10_;
 
348
                gchar* _tmp11_;
 
349
                gchar* _tmp12_;
 
350
                gchar* _tmp13_;
 
351
                gchar* _tmp14_;
 
352
                gchar* _tmp15_;
 
353
                gchar* _tmp16_;
 
354
                gchar* _tmp17_;
 
355
                gchar* _tmp18_;
 
356
                SQLHeavyQuery* _tmp19_ = NULL;
 
357
                SQLHeavyQuery* _tmp20_;
 
358
                SQLHeavyQuery* _tmp21_;
 
359
                if (self->priv->_sort_order == SQL_HEAVY_SORT_ORDER_ASCENDING) {
 
360
                        _tmp0_ = "ASC";
 
361
                } else {
 
362
                        _tmp0_ = "DESC";
 
363
                }
 
364
                _tmp1_ = sql_heavy_table_get_queryable (self->priv->_table);
 
365
                _tmp2_ = sql_heavy_table_get_name (self->priv->_table);
 
366
                _tmp3_ = sql_heavy_escape_string (_tmp2_);
 
367
                _tmp4_ = _tmp3_;
 
368
                _tmp5_ = g_strconcat ("SELECT `ROWID` FROM `", _tmp4_, NULL);
 
369
                _tmp6_ = _tmp5_;
 
370
                _tmp7_ = g_strconcat (_tmp6_, "` ORDER BY `", NULL);
 
371
                _tmp8_ = _tmp7_;
 
372
                _tmp9_ = sql_heavy_escape_string (self->priv->_sort_column);
 
373
                _tmp10_ = _tmp9_;
 
374
                _tmp11_ = g_strconcat (_tmp8_, _tmp10_, NULL);
 
375
                _tmp12_ = _tmp11_;
 
376
                _tmp13_ = g_strconcat (_tmp12_, "` ", NULL);
 
377
                _tmp14_ = _tmp13_;
 
378
                _tmp15_ = g_strconcat (_tmp14_, _tmp0_, NULL);
 
379
                _tmp16_ = _tmp15_;
 
380
                _tmp17_ = g_strconcat (_tmp16_, " LIMIT 1 OFFSET :offset;", NULL);
 
381
                _tmp18_ = _tmp17_;
 
382
                _tmp19_ = sql_heavy_queryable_prepare (_tmp1_, _tmp18_, &_inner_error_);
 
383
                _tmp20_ = _tmp19_;
 
384
                _g_free0 (_tmp18_);
 
385
                _g_free0 (_tmp16_);
 
386
                _g_free0 (_tmp14_);
 
387
                _g_free0 (_tmp12_);
 
388
                _g_free0 (_tmp10_);
 
389
                _g_free0 (_tmp8_);
 
390
                _g_free0 (_tmp6_);
 
391
                _g_free0 (_tmp4_);
 
392
                _tmp21_ = _tmp20_;
 
393
                if (_inner_error_ != NULL) {
 
394
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
395
                                goto __catch41_sql_heavy_error;
 
396
                        }
 
397
                        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);
 
398
                        g_clear_error (&_inner_error_);
 
399
                        return NULL;
 
400
                }
 
401
                _g_object_unref0 (self->priv->_query);
 
402
                self->priv->_query = _tmp21_;
 
403
                goto __finally41;
 
404
                __catch41_sql_heavy_error:
 
405
                {
 
406
                        GError * e;
 
407
                        e = _inner_error_;
 
408
                        _inner_error_ = NULL;
 
409
                        g_critical ("sqlheavy-table-cursor.vala:40: Unable to create table cursor: %s", e->message);
 
410
                        _g_error_free0 (e);
 
411
                }
 
412
                __finally41:
 
413
                if (_inner_error_ != NULL) {
 
414
                        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);
 
415
                        g_clear_error (&_inner_error_);
 
416
                        return NULL;
 
417
                }
 
418
        }
 
419
        result = self->priv->_query;
 
420
        return result;
 
421
}
 
422
 
 
423
 
 
424
static GObject * sql_heavy_table_cursor_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 
425
        GObject * obj;
 
426
        GObjectClass * parent_class;
 
427
        SQLHeavyTableCursor * self;
 
428
        GError * _inner_error_ = NULL;
 
429
        parent_class = G_OBJECT_CLASS (sql_heavy_table_cursor_parent_class);
 
430
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 
431
        self = SQL_HEAVY_TABLE_CURSOR (obj);
 
432
        sql_heavy_record_set_next ((SQLHeavyRecordSet*) self, &_inner_error_);
 
433
        if (_inner_error_ != NULL) {
 
434
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
435
                        goto __catch42_sql_heavy_error;
 
436
                }
 
437
                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);
 
438
                g_clear_error (&_inner_error_);
 
439
        }
 
440
        goto __finally42;
 
441
        __catch42_sql_heavy_error:
 
442
        {
 
443
                GError * e;
 
444
                e = _inner_error_;
 
445
                _inner_error_ = NULL;
 
446
                g_critical ("sqlheavy-table-cursor.vala:109: Unable to create table cursor: %s", e->message);
 
447
                _g_error_free0 (e);
 
448
        }
 
449
        __finally42:
 
450
        if (_inner_error_ != NULL) {
 
451
                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);
 
452
                g_clear_error (&_inner_error_);
 
453
        }
 
454
        return obj;
 
455
}
 
456
 
 
457
 
 
458
static void sql_heavy_table_cursor_class_init (SQLHeavyTableCursorClass * klass) {
 
459
        sql_heavy_table_cursor_parent_class = g_type_class_peek_parent (klass);
 
460
        g_type_class_add_private (klass, sizeof (SQLHeavyTableCursorPrivate));
 
461
        G_OBJECT_CLASS (klass)->get_property = _vala_sql_heavy_table_cursor_get_property;
 
462
        G_OBJECT_CLASS (klass)->set_property = _vala_sql_heavy_table_cursor_set_property;
 
463
        G_OBJECT_CLASS (klass)->constructor = sql_heavy_table_cursor_constructor;
 
464
        G_OBJECT_CLASS (klass)->finalize = sql_heavy_table_cursor_finalize;
 
465
        /**
 
466
             * The table
 
467
             */
 
468
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TABLE_CURSOR_TABLE, g_param_spec_object ("table", "table", "table", SQL_HEAVY_TYPE_TABLE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 
469
        /**
 
470
             * The current offset
 
471
             */
 
472
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TABLE_CURSOR_OFFSET, g_param_spec_int64 ("offset", "offset", "offset", G_MININT64, G_MAXINT64, (gint64) 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 
473
        /**
 
474
             * The order to sort the result set in
 
475
             */
 
476
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TABLE_CURSOR_SORT_ORDER, g_param_spec_enum ("sort-order", "sort-order", "sort-order", SQL_HEAVY_TYPE_SORT_ORDER, SQL_HEAVY_SORT_ORDER_ASCENDING, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
 
477
        /**
 
478
             * The column to sort the result set by
 
479
             */
 
480
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TABLE_CURSOR_SORT_COLUMN, g_param_spec_string ("sort-column", "sort-column", "sort-column", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
481
        /**
 
482
             * {@inheritDoc}
 
483
             */
 
484
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_TABLE_CURSOR_FIELD_COUNT, g_param_spec_int ("field-count", "field-count", "field-count", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 
485
}
 
486
 
 
487
 
 
488
static void sql_heavy_table_cursor_sql_heavy_record_set_interface_init (SQLHeavyRecordSetIface * iface) {
 
489
        sql_heavy_table_cursor_sql_heavy_record_set_parent_iface = g_type_interface_peek_parent (iface);
 
490
        iface->next = (gboolean (*)(SQLHeavyRecordSet* ,GError**)) sql_heavy_table_cursor_real_next;
 
491
}
 
492
 
 
493
 
 
494
static void sql_heavy_table_cursor_sql_heavy_cursor_interface_init (SQLHeavyCursorIface * iface) {
 
495
        sql_heavy_table_cursor_sql_heavy_cursor_parent_iface = g_type_interface_peek_parent (iface);
 
496
        iface->get = (SQLHeavyRecord* (*)(SQLHeavyCursor* ,GError**)) sql_heavy_table_cursor_real_get;
 
497
        iface->move_to = (gboolean (*)(SQLHeavyCursor* ,gint64 ,GError**)) sql_heavy_table_cursor_real_move_to;
 
498
        iface->previous = (gboolean (*)(SQLHeavyCursor* ,GError**)) sql_heavy_table_cursor_real_previous;
 
499
}
 
500
 
 
501
 
 
502
static void sql_heavy_table_cursor_instance_init (SQLHeavyTableCursor * self) {
 
503
        gchar* _tmp0_;
 
504
        self->priv = SQL_HEAVY_TABLE_CURSOR_GET_PRIVATE (self);
 
505
        self->priv->_offset = (gint64) 0;
 
506
        self->priv->_sort_order = SQL_HEAVY_SORT_ORDER_ASCENDING;
 
507
        _tmp0_ = g_strdup ("ROWID");
 
508
        self->priv->_sort_column = _tmp0_;
 
509
        self->priv->current_id = (gint64) (-1);
 
510
        self->priv->_query = NULL;
 
511
}
 
512
 
 
513
 
 
514
static void sql_heavy_table_cursor_finalize (GObject* obj) {
 
515
        SQLHeavyTableCursor * self;
 
516
        self = SQL_HEAVY_TABLE_CURSOR (obj);
 
517
        _g_object_unref0 (self->priv->_table);
 
518
        _g_free0 (self->priv->_sort_column);
 
519
        _g_object_unref0 (self->priv->_query);
 
520
        G_OBJECT_CLASS (sql_heavy_table_cursor_parent_class)->finalize (obj);
 
521
}
 
522
 
 
523
 
 
524
/**
 
525
   * Cursor for use with a {@link Table}
 
526
   */
 
527
GType sql_heavy_table_cursor_get_type (void) {
 
528
        static volatile gsize sql_heavy_table_cursor_type_id__volatile = 0;
 
529
        if (g_once_init_enter (&sql_heavy_table_cursor_type_id__volatile)) {
 
530
                static const GTypeInfo g_define_type_info = { sizeof (SQLHeavyTableCursorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) sql_heavy_table_cursor_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SQLHeavyTableCursor), 0, (GInstanceInitFunc) sql_heavy_table_cursor_instance_init, NULL };
 
531
                static const GInterfaceInfo sql_heavy_record_set_info = { (GInterfaceInitFunc) sql_heavy_table_cursor_sql_heavy_record_set_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
532
                static const GInterfaceInfo sql_heavy_cursor_info = { (GInterfaceInitFunc) sql_heavy_table_cursor_sql_heavy_cursor_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
533
                GType sql_heavy_table_cursor_type_id;
 
534
                sql_heavy_table_cursor_type_id = g_type_register_static (G_TYPE_OBJECT, "SQLHeavyTableCursor", &g_define_type_info, 0);
 
535
                g_type_add_interface_static (sql_heavy_table_cursor_type_id, SQL_HEAVY_TYPE_RECORD_SET, &sql_heavy_record_set_info);
 
536
                g_type_add_interface_static (sql_heavy_table_cursor_type_id, SQL_HEAVY_TYPE_CURSOR, &sql_heavy_cursor_info);
 
537
                g_once_init_leave (&sql_heavy_table_cursor_type_id__volatile, sql_heavy_table_cursor_type_id);
 
538
        }
 
539
        return sql_heavy_table_cursor_type_id__volatile;
 
540
}
 
541
 
 
542
 
 
543
static void _vala_sql_heavy_table_cursor_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
544
        SQLHeavyTableCursor * self;
 
545
        self = SQL_HEAVY_TABLE_CURSOR (object);
 
546
        switch (property_id) {
 
547
                case SQL_HEAVY_TABLE_CURSOR_TABLE:
 
548
                g_value_set_object (value, sql_heavy_table_cursor_get_table (self));
 
549
                break;
 
550
                case SQL_HEAVY_TABLE_CURSOR_OFFSET:
 
551
                g_value_set_int64 (value, sql_heavy_table_cursor_get_offset (self));
 
552
                break;
 
553
                case SQL_HEAVY_TABLE_CURSOR_SORT_ORDER:
 
554
                g_value_set_enum (value, sql_heavy_table_cursor_get_sort_order (self));
 
555
                break;
 
556
                case SQL_HEAVY_TABLE_CURSOR_SORT_COLUMN:
 
557
                g_value_set_string (value, sql_heavy_table_cursor_get_sort_column (self));
 
558
                break;
 
559
                case SQL_HEAVY_TABLE_CURSOR_FIELD_COUNT:
 
560
                g_value_set_int (value, sql_heavy_table_cursor_get_field_count (self));
 
561
                break;
 
562
                default:
 
563
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
564
                break;
 
565
        }
 
566
}
 
567
 
 
568
 
 
569
static void _vala_sql_heavy_table_cursor_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
570
        SQLHeavyTableCursor * self;
 
571
        self = SQL_HEAVY_TABLE_CURSOR (object);
 
572
        switch (property_id) {
 
573
                case SQL_HEAVY_TABLE_CURSOR_TABLE:
 
574
                sql_heavy_table_cursor_set_table (self, g_value_get_object (value));
 
575
                break;
 
576
                case SQL_HEAVY_TABLE_CURSOR_OFFSET:
 
577
                sql_heavy_table_cursor_set_offset (self, g_value_get_int64 (value));
 
578
                break;
 
579
                case SQL_HEAVY_TABLE_CURSOR_SORT_ORDER:
 
580
                sql_heavy_table_cursor_set_sort_order (self, g_value_get_enum (value));
 
581
                break;
 
582
                case SQL_HEAVY_TABLE_CURSOR_SORT_COLUMN:
 
583
                sql_heavy_table_cursor_set_sort_column (self, g_value_get_string (value));
 
584
                break;
 
585
                default:
 
586
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
587
                break;
 
588
        }
 
589
}
 
590
 
 
591
 
 
592