← Back to branch summary

~ubuntu-branches/debian/jessie/sqlheavy/jessie

« back to all changes in this revision

Viewing changes to sqlheavy/sqlheavy-mutable-record.c

  • Committer: Package Import Robot
  • Author(s): Devid Antonio Filoni
  • Date: 2012-05-17 09:47:17 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120517094717-ue17pqaud5tywjj5
Tags: 0.1.1-1
http://bugs.debian.org/663320
* New upstream release (Closes: #663320).
* Fix debug-package-should-be-priority-extra lintian warning.
* debian/control: switch to vala-0.16 in Build-Depends field.
* debian/libsqlheavy-dev.install, debian/libsqlheavygtk-dev.install:
  install files in vala-0.16 dir.
* Update libsqlheavy0.1-0.symbols.amd64 file.
* debian/rules: update override_dh_makeshlibs target.
* Bump Standards-Version to 3.9.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sqlheavy/sqlheavy-mutable-record.c
1
 
/* sqlheavy-mutable-record.c generated by valac 0.12.1, the Vala compiler
 
1
/* sqlheavy-mutable-record.c generated by valac 0.16.0, the Vala compiler
2
2
 * generated from sqlheavy-mutable-record.vala, do not modify */
3
3
 
4
4
 
39
39
     * @param value the value of the field
40
40
     */
41
41
void sql_heavy_mutable_record_put (SQLHeavyMutableRecord* self, gint field, GValue* value, GError** error) {
 
42
        g_return_if_fail (self != NULL);
42
43
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put (self, field, value, error);
43
44
}
44
45
 
50
51
     * @param value the value of the field
51
52
     */
52
53
static void sql_heavy_mutable_record_real_set (SQLHeavyMutableRecord* self, const gchar* field, GValue* value, GError** error) {
53
 
        gint _tmp0_;
54
 
        gint _tmp1_;
 
54
        const gchar* _tmp0_;
 
55
        gint _tmp1_ = 0;
 
56
        gint _tmp2_;
 
57
        GValue _tmp3_;
55
58
        GError * _inner_error_ = NULL;
56
59
        g_return_if_fail (field != NULL);
57
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
58
 
        _tmp1_ = _tmp0_;
 
60
        g_return_if_fail (value != NULL);
 
61
        _tmp0_ = field;
 
62
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
63
        _tmp2_ = _tmp1_;
59
64
        if (_inner_error_ != NULL) {
60
65
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
61
66
                        g_propagate_error (error, _inner_error_);
66
71
                        return;
67
72
                }
68
73
        }
69
 
        sql_heavy_mutable_record_put (self, _tmp1_, value, &_inner_error_);
 
74
        _tmp3_ = *value;
 
75
        sql_heavy_mutable_record_put (self, _tmp2_, &_tmp3_, &_inner_error_);
70
76
        if (_inner_error_ != NULL) {
71
77
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
72
78
                        g_propagate_error (error, _inner_error_);
81
87
 
82
88
 
83
89
void sql_heavy_mutable_record_set (SQLHeavyMutableRecord* self, const gchar* field, GValue* value, GError** error) {
 
90
        g_return_if_fail (self != NULL);
84
91
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set (self, field, value, error);
85
92
}
86
93
 
93
100
     * @see set_string
94
101
     */
95
102
static void sql_heavy_mutable_record_real_put_string (SQLHeavyMutableRecord* self, gint field, const gchar* value, GError** error) {
 
103
        const gchar* _tmp0_;
96
104
        GError * _inner_error_ = NULL;
97
 
        if (value == NULL) {
98
 
                sql_heavy_mutable_record_put_null (self, field, &_inner_error_);
 
105
        _tmp0_ = value;
 
106
        if (_tmp0_ == NULL) {
 
107
                gint _tmp1_;
 
108
                _tmp1_ = field;
 
109
                sql_heavy_mutable_record_put_null (self, _tmp1_, &_inner_error_);
99
110
                if (_inner_error_ != NULL) {
100
111
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
101
112
                                g_propagate_error (error, _inner_error_);
107
118
                        }
108
119
                }
109
120
        } else {
110
 
                GValue _tmp0_ = {0};
111
 
                g_value_init (&_tmp0_, G_TYPE_STRING);
112
 
                g_value_set_string (&_tmp0_, (const gchar*) value);
113
 
                sql_heavy_mutable_record_put (self, field, &_tmp0_, &_inner_error_);
114
 
                G_IS_VALUE (&_tmp0_) ? (g_value_unset (&_tmp0_), NULL) : NULL;
 
121
                gint _tmp2_;
 
122
                const gchar* _tmp3_;
 
123
                GValue _tmp4_ = {0};
 
124
                _tmp2_ = field;
 
125
                _tmp3_ = value;
 
126
                g_value_init (&_tmp4_, G_TYPE_STRING);
 
127
                g_value_set_string (&_tmp4_, (const gchar*) _tmp3_);
 
128
                sql_heavy_mutable_record_put (self, _tmp2_, &_tmp4_, &_inner_error_);
 
129
                G_IS_VALUE (&_tmp4_) ? (g_value_unset (&_tmp4_), NULL) : NULL;
115
130
                if (_inner_error_ != NULL) {
116
131
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
117
132
                                g_propagate_error (error, _inner_error_);
127
142
 
128
143
 
129
144
void sql_heavy_mutable_record_put_string (SQLHeavyMutableRecord* self, gint field, const gchar* value, GError** error) {
 
145
        g_return_if_fail (self != NULL);
130
146
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put_string (self, field, value, error);
131
147
}
132
148
 
139
155
     * @see put_string
140
156
     */
141
157
static void sql_heavy_mutable_record_real_set_string (SQLHeavyMutableRecord* self, const gchar* field, const gchar* value, GError** error) {
142
 
        gint _tmp0_;
143
 
        gint _tmp1_;
 
158
        const gchar* _tmp0_;
 
159
        gint _tmp1_ = 0;
 
160
        gint _tmp2_;
 
161
        const gchar* _tmp3_;
144
162
        GError * _inner_error_ = NULL;
145
163
        g_return_if_fail (field != NULL);
146
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
147
 
        _tmp1_ = _tmp0_;
 
164
        _tmp0_ = field;
 
165
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
166
        _tmp2_ = _tmp1_;
148
167
        if (_inner_error_ != NULL) {
149
168
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
150
169
                        g_propagate_error (error, _inner_error_);
155
174
                        return;
156
175
                }
157
176
        }
158
 
        sql_heavy_mutable_record_put_string (self, _tmp1_, value, &_inner_error_);
 
177
        _tmp3_ = value;
 
178
        sql_heavy_mutable_record_put_string (self, _tmp2_, _tmp3_, &_inner_error_);
159
179
        if (_inner_error_ != NULL) {
160
180
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
161
181
                        g_propagate_error (error, _inner_error_);
170
190
 
171
191
 
172
192
void sql_heavy_mutable_record_set_string (SQLHeavyMutableRecord* self, const gchar* field, const gchar* value, GError** error) {
 
193
        g_return_if_fail (self != NULL);
173
194
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set_string (self, field, value, error);
174
195
}
175
196
 
182
203
     */
183
204
static void sql_heavy_mutable_record_real_put_null (SQLHeavyMutableRecord* self, gint field, GError** error) {
184
205
        GValue _tmp0_ = {0};
185
 
        GValue _tmp1_ = {0};
186
206
        GValue gv;
 
207
        gint _tmp1_;
 
208
        GValue _tmp2_;
187
209
        GError * _inner_error_ = NULL;
188
210
        g_value_init (&_tmp0_, G_TYPE_POINTER);
189
 
        _tmp1_ = _tmp0_;
190
 
        gv = _tmp1_;
 
211
        gv = _tmp0_;
191
212
        g_value_set_pointer (&gv, NULL);
192
 
        sql_heavy_mutable_record_put (self, field, &gv, &_inner_error_);
 
213
        _tmp1_ = field;
 
214
        _tmp2_ = gv;
 
215
        sql_heavy_mutable_record_put (self, _tmp1_, &_tmp2_, &_inner_error_);
193
216
        if (_inner_error_ != NULL) {
194
217
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
195
218
                        g_propagate_error (error, _inner_error_);
207
230
 
208
231
 
209
232
void sql_heavy_mutable_record_put_null (SQLHeavyMutableRecord* self, gint field, GError** error) {
 
233
        g_return_if_fail (self != NULL);
210
234
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put_null (self, field, error);
211
235
}
212
236
 
218
242
     * @see put_null
219
243
     */
220
244
static void sql_heavy_mutable_record_real_set_null (SQLHeavyMutableRecord* self, const gchar* field, GError** error) {
221
 
        gint _tmp0_;
222
 
        gint _tmp1_;
 
245
        const gchar* _tmp0_;
 
246
        gint _tmp1_ = 0;
 
247
        gint _tmp2_;
223
248
        GError * _inner_error_ = NULL;
224
249
        g_return_if_fail (field != NULL);
225
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
226
 
        _tmp1_ = _tmp0_;
 
250
        _tmp0_ = field;
 
251
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
252
        _tmp2_ = _tmp1_;
227
253
        if (_inner_error_ != NULL) {
228
254
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
229
255
                        g_propagate_error (error, _inner_error_);
234
260
                        return;
235
261
                }
236
262
        }
237
 
        sql_heavy_mutable_record_put_null (self, _tmp1_, &_inner_error_);
 
263
        sql_heavy_mutable_record_put_null (self, _tmp2_, &_inner_error_);
238
264
        if (_inner_error_ != NULL) {
239
265
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
240
266
                        g_propagate_error (error, _inner_error_);
249
275
 
250
276
 
251
277
void sql_heavy_mutable_record_set_null (SQLHeavyMutableRecord* self, const gchar* field, GError** error) {
 
278
        g_return_if_fail (self != NULL);
252
279
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set_null (self, field, error);
253
280
}
254
281
 
261
288
     * @see set_int
262
289
     */
263
290
static void sql_heavy_mutable_record_real_put_int (SQLHeavyMutableRecord* self, gint field, gint value, GError** error) {
264
 
        GValue _tmp0_ = {0};
 
291
        gint _tmp0_;
 
292
        gint _tmp1_;
 
293
        GValue _tmp2_ = {0};
265
294
        GError * _inner_error_ = NULL;
266
 
        g_value_init (&_tmp0_, G_TYPE_INT);
267
 
        g_value_set_int (&_tmp0_, value);
268
 
        sql_heavy_mutable_record_put (self, field, &_tmp0_, &_inner_error_);
269
 
        G_IS_VALUE (&_tmp0_) ? (g_value_unset (&_tmp0_), NULL) : NULL;
 
295
        _tmp0_ = field;
 
296
        _tmp1_ = value;
 
297
        g_value_init (&_tmp2_, G_TYPE_INT);
 
298
        g_value_set_int (&_tmp2_, _tmp1_);
 
299
        sql_heavy_mutable_record_put (self, _tmp0_, &_tmp2_, &_inner_error_);
 
300
        G_IS_VALUE (&_tmp2_) ? (g_value_unset (&_tmp2_), NULL) : NULL;
270
301
        if (_inner_error_ != NULL) {
271
302
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
272
303
                        g_propagate_error (error, _inner_error_);
281
312
 
282
313
 
283
314
void sql_heavy_mutable_record_put_int (SQLHeavyMutableRecord* self, gint field, gint value, GError** error) {
 
315
        g_return_if_fail (self != NULL);
284
316
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put_int (self, field, value, error);
285
317
}
286
318
 
293
325
     * @see put_int
294
326
     */
295
327
static void sql_heavy_mutable_record_real_set_int (SQLHeavyMutableRecord* self, const gchar* field, gint value, GError** error) {
296
 
        gint _tmp0_;
297
 
        gint _tmp1_;
 
328
        const gchar* _tmp0_;
 
329
        gint _tmp1_ = 0;
 
330
        gint _tmp2_;
 
331
        gint _tmp3_;
298
332
        GError * _inner_error_ = NULL;
299
333
        g_return_if_fail (field != NULL);
300
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
301
 
        _tmp1_ = _tmp0_;
 
334
        _tmp0_ = field;
 
335
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
336
        _tmp2_ = _tmp1_;
302
337
        if (_inner_error_ != NULL) {
303
338
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
304
339
                        g_propagate_error (error, _inner_error_);
309
344
                        return;
310
345
                }
311
346
        }
312
 
        sql_heavy_mutable_record_put_int (self, _tmp1_, value, &_inner_error_);
 
347
        _tmp3_ = value;
 
348
        sql_heavy_mutable_record_put_int (self, _tmp2_, _tmp3_, &_inner_error_);
313
349
        if (_inner_error_ != NULL) {
314
350
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
315
351
                        g_propagate_error (error, _inner_error_);
324
360
 
325
361
 
326
362
void sql_heavy_mutable_record_set_int (SQLHeavyMutableRecord* self, const gchar* field, gint value, GError** error) {
 
363
        g_return_if_fail (self != NULL);
327
364
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set_int (self, field, value, error);
328
365
}
329
366
 
336
373
     * @see set_int64
337
374
     */
338
375
static void sql_heavy_mutable_record_real_put_int64 (SQLHeavyMutableRecord* self, gint field, gint64 value, GError** error) {
339
 
        GValue _tmp0_ = {0};
 
376
        gint _tmp0_;
 
377
        gint64 _tmp1_;
 
378
        GValue _tmp2_ = {0};
340
379
        GError * _inner_error_ = NULL;
341
 
        g_value_init (&_tmp0_, G_TYPE_INT64);
342
 
        g_value_set_int64 (&_tmp0_, value);
343
 
        sql_heavy_mutable_record_put (self, field, &_tmp0_, &_inner_error_);
344
 
        G_IS_VALUE (&_tmp0_) ? (g_value_unset (&_tmp0_), NULL) : NULL;
 
380
        _tmp0_ = field;
 
381
        _tmp1_ = value;
 
382
        g_value_init (&_tmp2_, G_TYPE_INT64);
 
383
        g_value_set_int64 (&_tmp2_, _tmp1_);
 
384
        sql_heavy_mutable_record_put (self, _tmp0_, &_tmp2_, &_inner_error_);
 
385
        G_IS_VALUE (&_tmp2_) ? (g_value_unset (&_tmp2_), NULL) : NULL;
345
386
        if (_inner_error_ != NULL) {
346
387
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
347
388
                        g_propagate_error (error, _inner_error_);
356
397
 
357
398
 
358
399
void sql_heavy_mutable_record_put_int64 (SQLHeavyMutableRecord* self, gint field, gint64 value, GError** error) {
 
400
        g_return_if_fail (self != NULL);
359
401
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put_int64 (self, field, value, error);
360
402
}
361
403
 
368
410
     * @see put_int64
369
411
     */
370
412
static void sql_heavy_mutable_record_real_set_int64 (SQLHeavyMutableRecord* self, const gchar* field, gint64 value, GError** error) {
371
 
        gint _tmp0_;
372
 
        gint _tmp1_;
 
413
        const gchar* _tmp0_;
 
414
        gint _tmp1_ = 0;
 
415
        gint _tmp2_;
 
416
        gint64 _tmp3_;
373
417
        GError * _inner_error_ = NULL;
374
418
        g_return_if_fail (field != NULL);
375
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
376
 
        _tmp1_ = _tmp0_;
 
419
        _tmp0_ = field;
 
420
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
421
        _tmp2_ = _tmp1_;
377
422
        if (_inner_error_ != NULL) {
378
423
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
379
424
                        g_propagate_error (error, _inner_error_);
384
429
                        return;
385
430
                }
386
431
        }
387
 
        sql_heavy_mutable_record_put_int64 (self, _tmp1_, value, &_inner_error_);
 
432
        _tmp3_ = value;
 
433
        sql_heavy_mutable_record_put_int64 (self, _tmp2_, _tmp3_, &_inner_error_);
388
434
        if (_inner_error_ != NULL) {
389
435
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
390
436
                        g_propagate_error (error, _inner_error_);
399
445
 
400
446
 
401
447
void sql_heavy_mutable_record_set_int64 (SQLHeavyMutableRecord* self, const gchar* field, gint64 value, GError** error) {
 
448
        g_return_if_fail (self != NULL);
402
449
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set_int64 (self, field, value, error);
403
450
}
404
451
 
411
458
     * @see set_double
412
459
     */
413
460
static void sql_heavy_mutable_record_real_put_double (SQLHeavyMutableRecord* self, gint field, gdouble value, GError** error) {
414
 
        GValue _tmp0_ = {0};
 
461
        gint _tmp0_;
 
462
        gdouble _tmp1_;
 
463
        GValue _tmp2_ = {0};
415
464
        GError * _inner_error_ = NULL;
416
 
        g_value_init (&_tmp0_, G_TYPE_DOUBLE);
417
 
        g_value_set_double (&_tmp0_, value);
418
 
        sql_heavy_mutable_record_put (self, field, &_tmp0_, &_inner_error_);
419
 
        G_IS_VALUE (&_tmp0_) ? (g_value_unset (&_tmp0_), NULL) : NULL;
 
465
        _tmp0_ = field;
 
466
        _tmp1_ = value;
 
467
        g_value_init (&_tmp2_, G_TYPE_DOUBLE);
 
468
        g_value_set_double (&_tmp2_, _tmp1_);
 
469
        sql_heavy_mutable_record_put (self, _tmp0_, &_tmp2_, &_inner_error_);
 
470
        G_IS_VALUE (&_tmp2_) ? (g_value_unset (&_tmp2_), NULL) : NULL;
420
471
        if (_inner_error_ != NULL) {
421
472
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
422
473
                        g_propagate_error (error, _inner_error_);
431
482
 
432
483
 
433
484
void sql_heavy_mutable_record_put_double (SQLHeavyMutableRecord* self, gint field, gdouble value, GError** error) {
 
485
        g_return_if_fail (self != NULL);
434
486
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put_double (self, field, value, error);
435
487
}
436
488
 
443
495
     * @see put_double
444
496
     */
445
497
static void sql_heavy_mutable_record_real_set_double (SQLHeavyMutableRecord* self, const gchar* field, gdouble value, GError** error) {
446
 
        gint _tmp0_;
447
 
        gint _tmp1_;
 
498
        const gchar* _tmp0_;
 
499
        gint _tmp1_ = 0;
 
500
        gint _tmp2_;
 
501
        gdouble _tmp3_;
448
502
        GError * _inner_error_ = NULL;
449
503
        g_return_if_fail (field != NULL);
450
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
451
 
        _tmp1_ = _tmp0_;
 
504
        _tmp0_ = field;
 
505
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
506
        _tmp2_ = _tmp1_;
452
507
        if (_inner_error_ != NULL) {
453
508
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
454
509
                        g_propagate_error (error, _inner_error_);
459
514
                        return;
460
515
                }
461
516
        }
462
 
        sql_heavy_mutable_record_put_double (self, _tmp1_, value, &_inner_error_);
 
517
        _tmp3_ = value;
 
518
        sql_heavy_mutable_record_put_double (self, _tmp2_, _tmp3_, &_inner_error_);
463
519
        if (_inner_error_ != NULL) {
464
520
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
465
521
                        g_propagate_error (error, _inner_error_);
474
530
 
475
531
 
476
532
void sql_heavy_mutable_record_set_double (SQLHeavyMutableRecord* self, const gchar* field, gdouble value, GError** error) {
 
533
        g_return_if_fail (self != NULL);
477
534
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set_double (self, field, value, error);
478
535
}
479
536
 
486
543
     * @see set_blob
487
544
     */
488
545
static void sql_heavy_mutable_record_real_put_blob (SQLHeavyMutableRecord* self, gint field, guint8* value, int value_length1, GError** error) {
489
 
        GByteArray* _tmp0_ = NULL;
 
546
        guint8* _tmp0_;
 
547
        gint _tmp0__length1;
 
548
        GByteArray* _tmp1_;
490
549
        GByteArray* ba;
491
 
        GValue _tmp1_ = {0};
 
550
        guint8* _tmp2_;
 
551
        gint _tmp2__length1;
 
552
        gint _tmp3_;
 
553
        GValue _tmp4_ = {0};
492
554
        GError * _inner_error_ = NULL;
493
 
        _tmp0_ = g_byte_array_sized_new ((guint) value_length1);
494
 
        ba = _tmp0_;
495
 
        g_byte_array_append (ba, value, value_length1);
496
 
        g_value_init (&_tmp1_, G_TYPE_BYTE_ARRAY);
497
 
        g_value_set_boxed (&_tmp1_, ba);
498
 
        sql_heavy_mutable_record_put (self, field, &_tmp1_, &_inner_error_);
499
 
        G_IS_VALUE (&_tmp1_) ? (g_value_unset (&_tmp1_), NULL) : NULL;
 
555
        _tmp0_ = value;
 
556
        _tmp0__length1 = value_length1;
 
557
        _tmp1_ = g_byte_array_sized_new ((guint) _tmp0__length1);
 
558
        ba = _tmp1_;
 
559
        _tmp2_ = value;
 
560
        _tmp2__length1 = value_length1;
 
561
        g_byte_array_append (ba, _tmp2_, _tmp2__length1);
 
562
        _tmp3_ = field;
 
563
        g_value_init (&_tmp4_, G_TYPE_BYTE_ARRAY);
 
564
        g_value_set_boxed (&_tmp4_, ba);
 
565
        sql_heavy_mutable_record_put (self, _tmp3_, &_tmp4_, &_inner_error_);
 
566
        G_IS_VALUE (&_tmp4_) ? (g_value_unset (&_tmp4_), NULL) : NULL;
500
567
        if (_inner_error_ != NULL) {
501
568
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
502
569
                        g_propagate_error (error, _inner_error_);
514
581
 
515
582
 
516
583
void sql_heavy_mutable_record_put_blob (SQLHeavyMutableRecord* self, gint field, guint8* value, int value_length1, GError** error) {
 
584
        g_return_if_fail (self != NULL);
517
585
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put_blob (self, field, value, value_length1, error);
518
586
}
519
587
 
526
594
     * @see put_blob
527
595
     */
528
596
static void sql_heavy_mutable_record_real_set_blob (SQLHeavyMutableRecord* self, const gchar* field, guint8* value, int value_length1, GError** error) {
529
 
        gint _tmp0_;
530
 
        gint _tmp1_;
 
597
        const gchar* _tmp0_;
 
598
        gint _tmp1_ = 0;
 
599
        gint _tmp2_;
 
600
        guint8* _tmp3_;
 
601
        gint _tmp3__length1;
531
602
        GError * _inner_error_ = NULL;
532
603
        g_return_if_fail (field != NULL);
533
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
534
 
        _tmp1_ = _tmp0_;
 
604
        _tmp0_ = field;
 
605
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
606
        _tmp2_ = _tmp1_;
535
607
        if (_inner_error_ != NULL) {
536
608
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
537
609
                        g_propagate_error (error, _inner_error_);
542
614
                        return;
543
615
                }
544
616
        }
545
 
        sql_heavy_mutable_record_put_blob (self, _tmp1_, value, value_length1, &_inner_error_);
 
617
        _tmp3_ = value;
 
618
        _tmp3__length1 = value_length1;
 
619
        sql_heavy_mutable_record_put_blob (self, _tmp2_, _tmp3_, _tmp3__length1, &_inner_error_);
546
620
        if (_inner_error_ != NULL) {
547
621
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
548
622
                        g_propagate_error (error, _inner_error_);
557
631
 
558
632
 
559
633
void sql_heavy_mutable_record_set_blob (SQLHeavyMutableRecord* self, const gchar* field, guint8* value, int value_length1, GError** error) {
 
634
        g_return_if_fail (self != NULL);
560
635
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set_blob (self, field, value, value_length1, error);
561
636
}
562
637
 
569
644
     * @see set_time_t
570
645
     */
571
646
static void sql_heavy_mutable_record_real_put_time_t (SQLHeavyMutableRecord* self, gint field, time_t value, GError** error) {
 
647
        gint _tmp0_;
 
648
        time_t _tmp1_;
572
649
        GError * _inner_error_ = NULL;
573
 
        sql_heavy_mutable_record_put_int64 (self, field, (gint64) value, &_inner_error_);
 
650
        _tmp0_ = field;
 
651
        _tmp1_ = value;
 
652
        sql_heavy_mutable_record_put_int64 (self, _tmp0_, (gint64) _tmp1_, &_inner_error_);
574
653
        if (_inner_error_ != NULL) {
575
654
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
576
655
                        g_propagate_error (error, _inner_error_);
585
664
 
586
665
 
587
666
void sql_heavy_mutable_record_put_time_t (SQLHeavyMutableRecord* self, gint field, time_t value, GError** error) {
 
667
        g_return_if_fail (self != NULL);
588
668
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->put_time_t (self, field, value, error);
589
669
}
590
670
 
597
677
     * @see put_time_t
598
678
     */
599
679
static void sql_heavy_mutable_record_real_set_time_t (SQLHeavyMutableRecord* self, const gchar* field, time_t value, GError** error) {
600
 
        gint _tmp0_;
601
 
        gint _tmp1_;
 
680
        const gchar* _tmp0_;
 
681
        gint _tmp1_ = 0;
 
682
        gint _tmp2_;
 
683
        time_t _tmp3_;
602
684
        GError * _inner_error_ = NULL;
603
685
        g_return_if_fail (field != NULL);
604
 
        _tmp0_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, field, &_inner_error_);
605
 
        _tmp1_ = _tmp0_;
 
686
        _tmp0_ = field;
 
687
        _tmp1_ = sql_heavy_record_field_index ((SQLHeavyRecord*) self, _tmp0_, &_inner_error_);
 
688
        _tmp2_ = _tmp1_;
606
689
        if (_inner_error_ != NULL) {
607
690
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
608
691
                        g_propagate_error (error, _inner_error_);
613
696
                        return;
614
697
                }
615
698
        }
616
 
        sql_heavy_mutable_record_put_time_t (self, _tmp1_, value, &_inner_error_);
 
699
        _tmp3_ = value;
 
700
        sql_heavy_mutable_record_put_time_t (self, _tmp2_, _tmp3_, &_inner_error_);
617
701
        if (_inner_error_ != NULL) {
618
702
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
619
703
                        g_propagate_error (error, _inner_error_);
628
712
 
629
713
 
630
714
void sql_heavy_mutable_record_set_time_t (SQLHeavyMutableRecord* self, const gchar* field, time_t value, GError** error) {
 
715
        g_return_if_fail (self != NULL);
631
716
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->set_time_t (self, field, value, error);
632
717
}
633
718
 
638
723
     * @see put
639
724
     */
640
725
void sql_heavy_mutable_record_save (SQLHeavyMutableRecord* self, GError** error) {
 
726
        g_return_if_fail (self != NULL);
641
727
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->save (self, error);
642
728
}
643
729
 
646
732
     * Delete the record from the database
647
733
     */
648
734
void sql_heavy_mutable_record_delete (SQLHeavyMutableRecord* self, GError** error) {
 
735
        g_return_if_fail (self != NULL);
649
736
        SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE (self)->delete (self, error);
650
737
}
651
738