« back to all changes in this revision
Viewing changes to test/core/my-object.c
- browse files at revision 10
- compare with another revision
- download diff
- download tarball
- view history from revision 10
- Committer: Bazaar Package Importer
- Author(s): Sebastian Dröge
- Date: 2007-07-06 14:00:42 UTC
- mfrom: (1.1.3 upstream)
- Revision ID: james.westby@ubuntu.com-20070706140042-zh5qmx99npmoe454
Tags: 0.74-1
* New upstream release.
* debian/rules:
+ Update shlibs to >= 0.74 because of new API.
* debian/control:
+ Use ${binary:Version} to make lintian happy.
* debian/rules:
+ Update shlibs to >= 0.74 because of new API.
* debian/control:
+ Use ${binary:Version} to make lintian happy.
- files removed:
- doc/reference/html/dbus-glib-GType-utility-functions.html
- files modified:
- AUTHORS
added
removed
test/core/my-object.c
1
#include <config.h>
2
#include <string.h>
3
#include <glib/gi18n.h>
4
#include <glib-object.h>
5
#include "my-object.h"
6
#include "my-object-marshal.h"
7
8
#include "test-service-glib-glue.h"
9
10
/* Properties */
11
enum
12
{
13
PROP_0,
14
PROP_THIS_IS_A_STRING
15
};
16
17
enum
18
{
19
FROBNICATE,
20
SIG0,
21
SIG1,
22
SIG2,
23
LAST_SIGNAL
24
};
25
26
static guint signals[LAST_SIGNAL] = { 0 };
27
28
G_DEFINE_TYPE(MyObject, my_object, G_TYPE_OBJECT)
29
30
static void
31
my_object_finalize (GObject *object)
32
{
33
MyObject *mobject = MY_OBJECT (object);
34
35
g_free (mobject->this_is_a_string);
36
37
(G_OBJECT_CLASS (my_object_parent_class)->finalize) (object);
38
}
39
40
static void
41
my_object_set_property (GObject *object,
42
guint prop_id,
43
const GValue *value,
44
GParamSpec *pspec)
45
{
46
MyObject *mobject;
47
48
mobject = MY_OBJECT (object);
49
50
switch (prop_id)
51
{
52
case PROP_THIS_IS_A_STRING:
53
g_free (mobject->this_is_a_string);
54
mobject->this_is_a_string = g_value_dup_string (value);
55
break;
56
57
default:
58
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
59
break;
60
}
61
}
62
63
static void
64
my_object_get_property (GObject *object,
65
guint prop_id,
66
GValue *value,
67
GParamSpec *pspec)
68
{
69
MyObject *mobject;
70
71
mobject = MY_OBJECT (object);
72
73
switch (prop_id)
74
{
75
case PROP_THIS_IS_A_STRING:
76
g_value_set_string (value, mobject->this_is_a_string);
77
break;
78
79
default:
80
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
81
break;
82
}
83
}
84
85
static void
86
my_object_init (MyObject *obj)
87
{
88
obj->val = 0;
89
}
90
91
static void
92
my_object_class_init (MyObjectClass *mobject_class)
93
{
94
GObjectClass *gobject_class = G_OBJECT_CLASS (mobject_class);
95
96
dbus_g_object_type_install_info (MY_TYPE_OBJECT,
97
&dbus_glib_my_object_object_info);
98
99
gobject_class->finalize = my_object_finalize;
100
gobject_class->set_property = my_object_set_property;
101
gobject_class->get_property = my_object_get_property;
102
103
g_object_class_install_property (gobject_class,
104
PROP_THIS_IS_A_STRING,
105
g_param_spec_string ("this_is_a_string",
106
_("Sample string"),
107
_("Example of a string property"),
108
"default value",
109
G_PARAM_READWRITE));
110
signals[FROBNICATE] =
111
g_signal_new ("frobnicate",
112
G_OBJECT_CLASS_TYPE (mobject_class),
113
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
114
0,
115
NULL, NULL,
116
g_cclosure_marshal_VOID__INT,
117
G_TYPE_NONE, 1, G_TYPE_INT);
118
119
signals[SIG0] =
120
g_signal_new ("sig0",
121
G_OBJECT_CLASS_TYPE (mobject_class),
122
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
123
0,
124
NULL, NULL,
125
my_object_marshal_VOID__STRING_INT_STRING,
126
G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
127
128
signals[SIG1] =
129
g_signal_new ("sig1",
130
G_OBJECT_CLASS_TYPE (mobject_class),
131
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
132
0,
133
NULL, NULL,
134
my_object_marshal_VOID__STRING_BOXED,
135
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_VALUE);
136
137
signals[SIG2] =
138
g_signal_new ("sig2",
139
G_OBJECT_CLASS_TYPE (mobject_class),
140
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
141
0,
142
NULL, NULL,
143
g_cclosure_marshal_VOID__BOXED,
144
G_TYPE_NONE, 1, DBUS_TYPE_G_STRING_STRING_HASHTABLE);
145
}
146
147
GQuark
148
my_object_error_quark (void)
149
{
150
static GQuark quark = 0;
151
if (!quark)
152
quark = g_quark_from_static_string ("my_object_error");
153
154
return quark;
155
}
156
157
/* This should really be standard. */
158
#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
159
160
GType
161
my_object_error_get_type (void)
162
{
163
static GType etype = 0;
164
165
if (etype == 0)
166
{
167
static const GEnumValue values[] =
168
{
169
170
ENUM_ENTRY (MY_OBJECT_ERROR_FOO, "Foo"),
171
ENUM_ENTRY (MY_OBJECT_ERROR_BAR, "Bar"),
172
{ 0, 0, 0 }
173
};
174
175
etype = g_enum_register_static ("MyObjectError", values);
176
}
177
178
return etype;
179
}
180
181
gboolean
182
my_object_do_nothing (MyObject *obj, GError **error)
183
{
184
return TRUE;
185
}
186
187
gboolean
188
my_object_increment (MyObject *obj, gint32 x, gint32 *ret, GError **error)
189
{
190
*ret = x +1;
191
return TRUE;
192
}
193
194
gint32
195
my_object_increment_retval (MyObject *obj, gint32 x)
196
{
197
return x + 1;
198
}
199
200
gint32
201
my_object_increment_retval_error (MyObject *obj, gint32 x, GError **error)
202
{
203
if (x + 1 > 10)
204
{
205
g_set_error (error,
206
MY_OBJECT_ERROR,
207
MY_OBJECT_ERROR_FOO,
208
"%s",
209
"x is bigger than 9");
210
return FALSE;
211
}
212
return x + 1;
213
}
214
215
gboolean
216
my_object_throw_error (MyObject *obj, GError **error)
217
{
218
g_set_error (error,
219
MY_OBJECT_ERROR,
220
MY_OBJECT_ERROR_FOO,
221
"%s",
222
"this method always loses");
223
return FALSE;
224
}
225
226
gboolean
227
my_object_uppercase (MyObject *obj, const char *str, char **ret, GError **error)
228
{
229
*ret = g_ascii_strup (str, -1);
230
return TRUE;
231
}
232
233
gboolean
234
my_object_many_args (MyObject *obj, guint32 x, const char *str, double trouble, double *d_ret, char **str_ret, GError **error)
235
{
236
*d_ret = trouble + (x * 2);
237
*str_ret = g_ascii_strup (str, -1);
238
return TRUE;
239
}
240
241
gboolean
242
my_object_many_return (MyObject *obj, guint32 *arg0, char **arg1, gint32 *arg2, guint32 *arg3, guint32 *arg4, const char **arg5, GError **error)
243
{
244
*arg0 = 42;
245
*arg1 = g_strdup ("42");
246
*arg2 = -67;
247
*arg3 = 2;
248
*arg4 = 26;
249
*arg5 = "hello world"; /* Annotation specifies as const */
250
return TRUE;
251
}
252
253
gboolean
254
my_object_stringify (MyObject *obj, GValue *value, char **ret, GError **error)
255
{
256
GValue valstr = {0, };
257
258
g_value_init (&valstr, G_TYPE_STRING);
259
if (!g_value_transform (value, &valstr))
260
{
261
g_set_error (error,
262
MY_OBJECT_ERROR,
263
MY_OBJECT_ERROR_FOO,
264
"couldn't transform value");
265
return FALSE;
266
}
267
*ret = g_value_dup_string (&valstr);
268
g_value_unset (&valstr);
269
return TRUE;
270
}
271
272
gboolean
273
my_object_unstringify (MyObject *obj, const char *str, GValue *value, GError **error)
274
{
275
if (str[0] == '\0' || !g_ascii_isdigit (str[0])) {
276
g_value_init (value, G_TYPE_STRING);
277
g_value_set_string (value, str);
278
} else {
279
g_value_init (value, G_TYPE_INT);
280
g_value_set_int (value, (int) g_ascii_strtoull (str, NULL, 10));
281
}
282
return TRUE;
283
}
284
285
gboolean
286
my_object_recursive1 (MyObject *obj, GArray *array, guint32 *len_ret, GError **error)
287
{
288
*len_ret = array->len;
289
return TRUE;
290
}
291
292
gboolean
293
my_object_recursive2 (MyObject *obj, guint32 reqlen, GArray **ret, GError **error)
294
{
295
guint32 val;
296
GArray *array;
297
298
array = g_array_new (FALSE, TRUE, sizeof (guint32));
299
300
while (reqlen > 0) {
301
val = 42;
302
g_array_append_val (array, val);
303
val = 26;
304
g_array_append_val (array, val);
305
reqlen--;
306
}
307
val = 2;
308
g_array_append_val (array, val);
309
*ret = array;
310
return TRUE;
311
}
312
313
gboolean
314
my_object_many_uppercase (MyObject *obj, const char * const *in, char ***out, GError **error)
315
{
316
int len;
317
int i;
318
319
len = g_strv_length ((char**) in);
320
321
*out = g_new0 (char *, len + 1);
322
for (i = 0; i < len; i++)
323
{
324
(*out)[i] = g_ascii_strup (in[i], -1);
325
}
326
(*out)[i] = NULL;
327
328
return TRUE;
329
}
330
331
static void
332
hash_foreach_stringify (gpointer key, gpointer val, gpointer user_data)
333
{
334
const char *keystr = key;
335
const GValue *value = val;
336
GValue *sval;
337
GHashTable *ret = user_data;
338
339
sval = g_new0 (GValue, 1);
340
g_value_init (sval, G_TYPE_STRING);
341
if (!g_value_transform (value, sval))
342
g_assert_not_reached ();
343
344
g_hash_table_insert (ret, g_strdup (keystr), sval);
345
}
346
347
static void
348
unset_and_free_gvalue (gpointer val)
349
{
350
g_value_unset (val);
351
g_free (val);
352
}
353
354
gboolean
355
my_object_many_stringify (MyObject *obj, GHashTable /* char * -> GValue * */ *vals, GHashTable /* char * -> GValue * */ **ret, GError **error)
356
{
357
*ret = g_hash_table_new_full (g_str_hash, g_str_equal,
358
g_free, unset_and_free_gvalue);
359
g_hash_table_foreach (vals, hash_foreach_stringify, *ret);
360
return TRUE;
361
}
362
363
gboolean
364
my_object_rec_arrays (MyObject *obj, GPtrArray *in, GPtrArray **ret, GError **error)
365
{
366
char **strs;
367
GArray *ints;
368
guint v_UINT;
369
370
if (in->len != 2)
371
{
372
g_set_error (error,
373
MY_OBJECT_ERROR,
374
MY_OBJECT_ERROR_FOO,
375
"invalid array len");
376
return FALSE;
377
}
378
379
strs = g_ptr_array_index (in, 0);
380
if (!*strs || strcmp (*strs, "foo"))
381
{
382
g_set_error (error,
383
MY_OBJECT_ERROR,
384
MY_OBJECT_ERROR_FOO,
385
"invalid string 0");
386
return FALSE;
387
}
388
strs++;
389
if (!*strs || strcmp (*strs, "bar"))
390
{
391
g_set_error (error,
392
MY_OBJECT_ERROR,
393
MY_OBJECT_ERROR_FOO,
394
"invalid string 1");
395
return FALSE;
396
}
397
strs++;
398
if (*strs)
399
{
400
g_set_error (error,
401
MY_OBJECT_ERROR,
402
MY_OBJECT_ERROR_FOO,
403
"invalid string array len in pos 0");
404
return FALSE;
405
}
406
strs = g_ptr_array_index (in, 1);
407
if (!*strs || strcmp (*strs, "baz"))
408
{
409
g_set_error (error,
410
MY_OBJECT_ERROR,
411
MY_OBJECT_ERROR_FOO,
412
"invalid string 0");
413
return FALSE;
414
}
415
strs++;
416
if (!*strs || strcmp (*strs, "whee"))
417
{
418
g_set_error (error,
419
MY_OBJECT_ERROR,
420
MY_OBJECT_ERROR_FOO,
421
"invalid string 1");
422
return FALSE;
423
}
424
strs++;
425
if (!*strs || strcmp (*strs, "moo"))
426
{
427
g_set_error (error,
428
MY_OBJECT_ERROR,
429
MY_OBJECT_ERROR_FOO,
430
"invalid string 2");
431
return FALSE;
432
}
433
strs++;
434
if (*strs)
435
{
436
g_set_error (error,
437
MY_OBJECT_ERROR,
438
MY_OBJECT_ERROR_FOO,
439
"invalid string array len in pos 1");
440
return FALSE;
441
}
442
443
*ret = g_ptr_array_new ();
444
445
ints = g_array_new (TRUE, TRUE, sizeof (guint));
446
v_UINT = 10;
447
g_array_append_val (ints, v_UINT);
448
v_UINT = 42;
449
g_array_append_val (ints, v_UINT);
450
v_UINT = 27;
451
g_array_append_val (ints, v_UINT);
452
g_ptr_array_add (*ret, ints);
453
454
ints = g_array_new (TRUE, TRUE, sizeof (guint));
455
v_UINT = 30;
456
g_array_append_val (ints, v_UINT);
457
g_ptr_array_add (*ret, ints);
458
return TRUE;
459
}
460
461
gboolean
462
my_object_objpath (MyObject *obj, const char *incoming, const char **outgoing, GError **error)
463
{
464
if (strcmp (incoming, "/org/freedesktop/DBus/GLib/Tests/MyTestObject"))
465
{
466
g_set_error (error,
467
MY_OBJECT_ERROR,
468
MY_OBJECT_ERROR_FOO,
469
"invalid incoming object");
470
return FALSE;
471
}
472
*outgoing = "/org/freedesktop/DBus/GLib/Tests/MyTestObject2";
473
return TRUE;
474
}
475
476
gboolean
477
my_object_get_objs (MyObject *obj, GPtrArray **objs, GError **error)
478
{
479
*objs = g_ptr_array_new ();
480
481
g_ptr_array_add (*objs, g_strdup ("/org/freedesktop/DBus/GLib/Tests/MyTestObject"));
482
g_ptr_array_add (*objs, g_strdup ("/org/freedesktop/DBus/GLib/Tests/MyTestObject2"));
483
484
return TRUE;
485
}
486
487
static void
488
hash_foreach (gpointer key, gpointer val, gpointer user_data)
489
{
490
const char *keystr = key;
491
const char *valstr = val;
492
guint *count = user_data;
493
494
*count += (strlen (keystr) + strlen (valstr));
495
g_print ("%s -> %s\n", keystr, valstr);
496
}
497
498
gboolean
499
my_object_str_hash_len (MyObject *obj, GHashTable *table, guint *len, GError **error)
500
{
501
*len = 0;
502
g_hash_table_foreach (table, hash_foreach, len);
503
return TRUE;
504
}
505
506
gboolean
507
my_object_send_car (MyObject *obj, GValueArray *invals, GValueArray **outvals, GError **error)
508
{
509
if (invals->n_values != 3
510
|| G_VALUE_TYPE (g_value_array_get_nth (invals, 0)) != G_TYPE_STRING
511
|| G_VALUE_TYPE (g_value_array_get_nth (invals, 1)) != G_TYPE_UINT
512
|| G_VALUE_TYPE (g_value_array_get_nth (invals, 2)) != G_TYPE_VALUE)
513
{
514
g_set_error (error,
515
MY_OBJECT_ERROR,
516
MY_OBJECT_ERROR_FOO,
517
"invalid incoming values");
518
return FALSE;
519
}
520
*outvals = g_value_array_new (2);
521
g_value_array_append (*outvals, NULL);
522
g_value_init (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1), G_TYPE_UINT);
523
g_value_set_uint (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1),
524
g_value_get_uint (g_value_array_get_nth (invals, 1)) + 1);
525
g_value_array_append (*outvals, NULL);
526
g_value_init (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1), DBUS_TYPE_G_OBJECT_PATH);
527
g_value_set_boxed (g_value_array_get_nth (*outvals, (*outvals)->n_values - 1),
528
g_strdup ("/org/freedesktop/DBus/GLib/Tests/MyTestObject2"));
529
return TRUE;
530
}
531
532
gboolean
533
my_object_get_hash (MyObject *obj, GHashTable **ret, GError **error)
534
{
535
GHashTable *table;
536
537
table = g_hash_table_new (g_str_hash, g_str_equal);
538
g_hash_table_insert (table, "foo", "bar");
539
g_hash_table_insert (table, "baz", "whee");
540
g_hash_table_insert (table, "cow", "crack");
541
*ret = table;
542
return TRUE;
543
}
544
545
gboolean
546
my_object_increment_val (MyObject *obj, GError **error)
547
{
548
obj->val++;
549
return TRUE;
550
}
551
552
gboolean
553
my_object_get_val (MyObject *obj, guint *ret, GError **error)
554
{
555
*ret = obj->val;
556
return TRUE;
557
}
558
559
gboolean
560
my_object_get_value (MyObject *obj, guint *ret, GError **error)
561
{
562
*ret = obj->val;
563
return TRUE;
564
}
565
566
gboolean
567
my_object_echo_variant (MyObject *obj, GValue *variant, GValue *ret, GError **error)
568
{
569
GType t;
570
t = G_VALUE_TYPE(variant);
571
g_value_init (ret, t);
572
g_value_copy (variant, ret);
573
574
return TRUE;
575
}
576
577
gboolean
578
my_object_process_variant_of_array_of_ints123 (MyObject *obj, GValue *variant, GError **error)
579
{
580
GArray *array;
581
int i;
582
int j;
583
584
j = 0;
585
586
array = (GArray *)g_value_get_boxed (variant);
587
588
for (i = 0; i <= 2; i++)
589
{
590
j = g_array_index (array, int, i);
591
if (j != i + 1)
592
goto error;
593
}
594
595
return TRUE;
596
597
error:
598
*error = g_error_new (MY_OBJECT_ERROR,
599
MY_OBJECT_ERROR_FOO,
600
"Error decoding a variant of type ai (i + 1 = %i, j = %i)",
601
i, j + 1);
602
return FALSE;
603
}
604
605
606
typedef struct _HashAndString HashAndString;
607
608
struct _HashAndString
609
{
610
GHashTable *hash;
611
gchar* string;
612
};
613
614
static void
615
hash_foreach_prepend_string (gpointer key, gpointer val, gpointer user_data)
616
{
617
HashAndString *data = (HashAndString*) user_data;
618
gchar *in = (gchar*) val;
619
g_hash_table_insert (data->hash, g_strdup ((gchar*) key),
620
g_strjoin (" ", data->string, in, NULL));
621
}
622
623
624
static void
625
hash_foreach_mangle_dict_of_strings (gpointer key, gpointer val, gpointer user_data)
626
{
627
GHashTable *out = (GHashTable*) user_data;
628
GHashTable *in_dict = (GHashTable *) val;
629
HashAndString *data = g_new0 (HashAndString, 1);
630
631
data->string = (gchar*) key;
632
data->hash = g_hash_table_new_full (g_str_hash, g_str_equal,
633
g_free, g_free);
634
g_hash_table_foreach (in_dict, hash_foreach_prepend_string, data);
635
636
g_hash_table_insert(out, g_strdup ((gchar*) key), data->hash);
637
}
638
639
gboolean
640
my_object_dict_of_dicts (MyObject *obj, GHashTable *in,
641
GHashTable **out, GError **error)
642
{
643
*out = g_hash_table_new_full (g_str_hash, g_str_equal,
644
(GDestroyNotify) g_free,
645
(GDestroyNotify) g_hash_table_destroy);
646
g_hash_table_foreach (in, hash_foreach_mangle_dict_of_strings, *out);
647
return TRUE;
648
}
649
650
gboolean
651
my_object_emit_frobnicate (MyObject *obj, GError **error)
652
{
653
g_signal_emit (obj, signals[FROBNICATE], 0, 42);
654
return TRUE;
655
}
656
657
gboolean
658
my_object_emit_signals (MyObject *obj, GError **error)
659
{
660
GValue val = {0, };
661
662
g_signal_emit (obj, signals[SIG0], 0, "foo", 22, "moo");
663
664
g_value_init (&val, G_TYPE_STRING);
665
g_value_set_string (&val, "bar");
666
g_signal_emit (obj, signals[SIG1], 0, "baz", &val);
667
g_value_unset (&val);
668
669
return TRUE;
670
}
671
672
gboolean
673
my_object_emit_signal2 (MyObject *obj, GError **error)
674
{
675
GHashTable *table;
676
677
table = g_hash_table_new (g_str_hash, g_str_equal);
678
g_hash_table_insert (table, "baz", "cow");
679
g_hash_table_insert (table, "bar", "foo");
680
g_signal_emit (obj, signals[SIG2], 0, table);
681
g_hash_table_destroy (table);
682
return TRUE;
683
}
684
685
typedef struct {
686
gint32 x;
687
DBusGMethodInvocation *context;
688
} IncrementData;
689
690
static gboolean
691
do_async_increment (IncrementData *data)
692
{
693
gint32 newx = data->x + 1;
694
dbus_g_method_return (data->context, newx);
695
g_free (data);
696
return FALSE;
697
}
698
699
void
700
my_object_async_increment (MyObject *obj, gint32 x, DBusGMethodInvocation *context)
701
{
702
IncrementData *data = g_new0 (IncrementData, 1);
703
data->x = x;
704
data->context = context;
705
g_idle_add ((GSourceFunc)do_async_increment, data);
706
}
707
708
static gboolean
709
do_async_error (IncrementData *data)
710
{
711
GError *error;
712
error = g_error_new (MY_OBJECT_ERROR,
713
MY_OBJECT_ERROR_FOO,
714
"%s",
715
"this method always loses");
716
dbus_g_method_return_error (data->context, error);
717
g_free (data);
718
return FALSE;
719
}
720
721
void
722
my_object_async_throw_error (MyObject *obj, DBusGMethodInvocation *context)
723
{
724
IncrementData *data = g_new0(IncrementData, 1);
725
data->context = context;
726
g_idle_add ((GSourceFunc)do_async_error, data);
727
}
728
729
730
extern GMainLoop *loop;
731
732
gboolean
733
my_object_terminate (MyObject *obj, GError **error)
734
{
735
g_main_loop_quit (loop);
736
return TRUE;
737
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1