← Back to branch summary

~ubuntu-branches/ubuntu/precise/evolution-data-server/precise

« back to all changes in this revision

Viewing changes to addressbook/libegdbus/e-gdbus-marshallers.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel-Lapierre, Ken VanDine, Mathieu Trudel-Lapierre
  • Date: 2011-06-23 17:40:41 UTC
  • mfrom: (1.1.88 upstream)
  • Revision ID: james.westby@ubuntu.com-20110623174041-4wd9jvs07wfinyet
Tags: 3.1.2-0ubuntu1
https://launchpad.net/bugs/385859
https://launchpad.net/bugs/781391
https://launchpad.net/bugs/160304
* New upstream version
  - bgo 589495 - Search folder by Size (KB) counts bytes, not KB (LP: #385859)
  - bgo 649757 - Filtering on a source account always succeeded (LP: #781391)
  - bgo 418954 - Add a separate entry combo for port numbers (LP: #160304)

[ Ken VanDine ]
* debian/libebook1.2-dev.install
  - Include EBook-1.2.gir
* debian/control
  - Added gir1.2-ebook-1.2 binary

[ Mathieu Trudel-Lapierre ]
* debian/control: drop libegroupwise1.2-13, libegroupwise-dev, they are now
  an independent module.
* debian/libegroupwise1.2-13.install,
  debian/libegroupwise1.2-dev.install,
  debian/lintian/libegroupwise1.2-13: dropped, see above.
* debian/control, debian/libe*.install, debian/lintian/libe*: rename and
  update files where needed to follow upstream soname changes.
* debian/control: bump evolution-data-server's Depends to libcamel-1.2-26.
* debian/rules: update to use makeshlibs with the new libcamel soname.

Show diffs side-by-side

added added

removed removed

Lines of Context:
addressbook/libegdbus/e-gdbus-marshallers.c
1
 
#include "e-gdbus-marshallers.h"
2
 
 
3
 
#include        <glib-object.h>
4
 
 
5
 
#ifdef G_ENABLE_DEBUG
6
 
#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
7
 
#define g_marshal_value_peek_char(v)     g_value_get_char (v)
8
 
#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
9
 
#define g_marshal_value_peek_int(v)      g_value_get_int (v)
10
 
#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
11
 
#define g_marshal_value_peek_long(v)     g_value_get_long (v)
12
 
#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
13
 
#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
14
 
#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
15
 
#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
16
 
#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
17
 
#define g_marshal_value_peek_float(v)    g_value_get_float (v)
18
 
#define g_marshal_value_peek_double(v)   g_value_get_double (v)
19
 
#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
20
 
#define g_marshal_value_peek_param(v)    g_value_get_param (v)
21
 
#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
22
 
#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
23
 
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
24
 
#define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
25
 
#else /* !G_ENABLE_DEBUG */
26
 
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
27
 
 *          Do not access GValues directly in your code. Instead, use the
28
 
 *          g_value_get_*() functions
29
 
 */
30
 
#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
31
 
#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
32
 
#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
33
 
#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
34
 
#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
35
 
#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
36
 
#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
37
 
#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
38
 
#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
39
 
#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
40
 
#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
41
 
#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
42
 
#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
43
 
#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
44
 
#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
45
 
#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
46
 
#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
47
 
#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
48
 
#define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
49
 
#endif /* G_ENABLE_DEBUG */
50
 
 
51
 
/* BOOLEAN:OBJECT,STRING (e-gdbus-marshallers.list:1) */
52
 
void
53
 
_e_gdbus_gdbus_cclosure_marshaller_BOOLEAN__OBJECT_STRING (GClosure     *closure,
54
 
                                                           GValue       *return_value G_GNUC_UNUSED,
55
 
                                                           guint         n_param_values,
56
 
                                                           const GValue *param_values,
57
 
                                                           gpointer      invocation_hint G_GNUC_UNUSED,
58
 
                                                           gpointer      marshal_data)
59
 
{
60
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING) (gpointer     data1,
61
 
                                                           gpointer     arg_1,
62
 
                                                           gpointer     arg_2,
63
 
                                                           gpointer     data2);
64
 
  register GMarshalFunc_BOOLEAN__OBJECT_STRING callback;
65
 
  register GCClosure *cc = (GCClosure*) closure;
66
 
  register gpointer data1, data2;
67
 
  gboolean v_return;
68
 
 
69
 
  g_return_if_fail (return_value != NULL);
70
 
  g_return_if_fail (n_param_values == 3);
71
 
 
72
 
  if (G_CCLOSURE_SWAP_DATA (closure))
73
 
    {
74
 
      data1 = closure->data;
75
 
      data2 = g_value_peek_pointer (param_values + 0);
76
 
    }
77
 
  else
78
 
    {
79
 
      data1 = g_value_peek_pointer (param_values + 0);
80
 
      data2 = closure->data;
81
 
    }
82
 
  callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING) (marshal_data ? marshal_data : cc->callback);
83
 
 
84
 
  v_return = callback (data1,
85
 
                       g_marshal_value_peek_object (param_values + 1),
86
 
                       g_marshal_value_peek_string (param_values + 2),
87
 
                       data2);
88
 
 
89
 
  g_value_set_boolean (return_value, v_return);
90
 
}
91
 
 
92
 
/* VOID:BOXED (e-gdbus-marshallers.list:2) */
93
 
 
94
 
/* VOID:STRING (e-gdbus-marshallers.list:3) */
95
 
 
96
 
/* VOID:UINT,STRING (e-gdbus-marshallers.list:4) */
97
 
void
98
 
_e_gdbus_gdbus_cclosure_marshaller_VOID__UINT_STRING (GClosure     *closure,
99
 
                                                      GValue       *return_value G_GNUC_UNUSED,
100
 
                                                      guint         n_param_values,
101
 
                                                      const GValue *param_values,
102
 
                                                      gpointer      invocation_hint G_GNUC_UNUSED,
103
 
                                                      gpointer      marshal_data)
104
 
{
105
 
  typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer     data1,
106
 
                                                  guint        arg_1,
107
 
                                                  gpointer     arg_2,
108
 
                                                  gpointer     data2);
109
 
  register GMarshalFunc_VOID__UINT_STRING callback;
110
 
  register GCClosure *cc = (GCClosure*) closure;
111
 
  register gpointer data1, data2;
112
 
 
113
 
  g_return_if_fail (n_param_values == 3);
114
 
 
115
 
  if (G_CCLOSURE_SWAP_DATA (closure))
116
 
    {
117
 
      data1 = closure->data;
118
 
      data2 = g_value_peek_pointer (param_values + 0);
119
 
    }
120
 
  else
121
 
    {
122
 
      data1 = g_value_peek_pointer (param_values + 0);
123
 
      data2 = closure->data;
124
 
    }
125
 
  callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
126
 
 
127
 
  callback (data1,
128
 
            g_marshal_value_peek_uint (param_values + 1),
129
 
            g_marshal_value_peek_string (param_values + 2),
130
 
            data2);
131
 
}
132
 
 
133
 
/* BOOLEAN:OBJECT (e-gdbus-marshallers.list:5) */
134
 
void
135
 
_e_gdbus_gdbus_cclosure_marshaller_BOOLEAN__OBJECT (GClosure     *closure,
136
 
                                                    GValue       *return_value G_GNUC_UNUSED,
137
 
                                                    guint         n_param_values,
138
 
                                                    const GValue *param_values,
139
 
                                                    gpointer      invocation_hint G_GNUC_UNUSED,
140
 
                                                    gpointer      marshal_data)
141
 
{
142
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer     data1,
143
 
                                                    gpointer     arg_1,
144
 
                                                    gpointer     data2);
145
 
  register GMarshalFunc_BOOLEAN__OBJECT callback;
146
 
  register GCClosure *cc = (GCClosure*) closure;
147
 
  register gpointer data1, data2;
148
 
  gboolean v_return;
149
 
 
150
 
  g_return_if_fail (return_value != NULL);
151
 
  g_return_if_fail (n_param_values == 2);
152
 
 
153
 
  if (G_CCLOSURE_SWAP_DATA (closure))
154
 
    {
155
 
      data1 = closure->data;
156
 
      data2 = g_value_peek_pointer (param_values + 0);
157
 
    }
158
 
  else
159
 
    {
160
 
      data1 = g_value_peek_pointer (param_values + 0);
161
 
      data2 = closure->data;
162
 
    }
163
 
  callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
164
 
 
165
 
  v_return = callback (data1,
166
 
                       g_marshal_value_peek_object (param_values + 1),
167
 
                       data2);
168
 
 
169
 
  g_value_set_boolean (return_value, v_return);
170
 
}
171
 
 
172
 
/* VOID:BOOLEAN (e-gdbus-marshallers.list:6) */
173
 
 
174
 
/* BOOLEAN:OBJECT,BOOLEAN (e-gdbus-marshallers.list:7) */
175
 
void
176
 
_e_gdbus_gdbus_cclosure_marshaller_BOOLEAN__OBJECT_BOOLEAN (GClosure     *closure,
177
 
                                                            GValue       *return_value G_GNUC_UNUSED,
178
 
                                                            guint         n_param_values,
179
 
                                                            const GValue *param_values,
180
 
                                                            gpointer      invocation_hint G_GNUC_UNUSED,
181
 
                                                            gpointer      marshal_data)
182
 
{
183
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOOLEAN) (gpointer     data1,
184
 
                                                            gpointer     arg_1,
185
 
                                                            gboolean     arg_2,
186
 
                                                            gpointer     data2);
187
 
  register GMarshalFunc_BOOLEAN__OBJECT_BOOLEAN callback;
188
 
  register GCClosure *cc = (GCClosure*) closure;
189
 
  register gpointer data1, data2;
190
 
  gboolean v_return;
191
 
 
192
 
  g_return_if_fail (return_value != NULL);
193
 
  g_return_if_fail (n_param_values == 3);
194
 
 
195
 
  if (G_CCLOSURE_SWAP_DATA (closure))
196
 
    {
197
 
      data1 = closure->data;
198
 
      data2 = g_value_peek_pointer (param_values + 0);
199
 
    }
200
 
  else
201
 
    {
202
 
      data1 = g_value_peek_pointer (param_values + 0);
203
 
      data2 = closure->data;
204
 
    }
205
 
  callback = (GMarshalFunc_BOOLEAN__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
206
 
 
207
 
  v_return = callback (data1,
208
 
                       g_marshal_value_peek_object (param_values + 1),
209
 
                       g_marshal_value_peek_boolean (param_values + 2),
210
 
                       data2);
211
 
 
212
 
  g_value_set_boolean (return_value, v_return);
213
 
}
214
 
 
215
 
/* BOOLEAN:OBJECT,STRING,STRING,STRING (e-gdbus-marshallers.list:8) */
216
 
void
217
 
_e_gdbus_gdbus_cclosure_marshaller_BOOLEAN__OBJECT_STRING_STRING_STRING (GClosure     *closure,
218
 
                                                                         GValue       *return_value G_GNUC_UNUSED,
219
 
                                                                         guint         n_param_values,
220
 
                                                                         const GValue *param_values,
221
 
                                                                         gpointer      invocation_hint G_GNUC_UNUSED,
222
 
                                                                         gpointer      marshal_data)
223
 
{
224
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_STRING) (gpointer     data1,
225
 
                                                                         gpointer     arg_1,
226
 
                                                                         gpointer     arg_2,
227
 
                                                                         gpointer     arg_3,
228
 
                                                                         gpointer     arg_4,
229
 
                                                                         gpointer     data2);
230
 
  register GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_STRING callback;
231
 
  register GCClosure *cc = (GCClosure*) closure;
232
 
  register gpointer data1, data2;
233
 
  gboolean v_return;
234
 
 
235
 
  g_return_if_fail (return_value != NULL);
236
 
  g_return_if_fail (n_param_values == 5);
237
 
 
238
 
  if (G_CCLOSURE_SWAP_DATA (closure))
239
 
    {
240
 
      data1 = closure->data;
241
 
      data2 = g_value_peek_pointer (param_values + 0);
242
 
    }
243
 
  else
244
 
    {
245
 
      data1 = g_value_peek_pointer (param_values + 0);
246
 
      data2 = closure->data;
247
 
    }
248
 
  callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
249
 
 
250
 
  v_return = callback (data1,
251
 
                       g_marshal_value_peek_object (param_values + 1),
252
 
                       g_marshal_value_peek_string (param_values + 2),
253
 
                       g_marshal_value_peek_string (param_values + 3),
254
 
                       g_marshal_value_peek_string (param_values + 4),
255
 
                       data2);
256
 
 
257
 
  g_value_set_boolean (return_value, v_return);
258
 
}
259
 
 
260
 
/* BOOLEAN:OBJECT,BOXED (e-gdbus-marshallers.list:9) */
261
 
void
262
 
_e_gdbus_gdbus_cclosure_marshaller_BOOLEAN__OBJECT_BOXED (GClosure     *closure,
263
 
                                                          GValue       *return_value G_GNUC_UNUSED,
264
 
                                                          guint         n_param_values,
265
 
                                                          const GValue *param_values,
266
 
                                                          gpointer      invocation_hint G_GNUC_UNUSED,
267
 
                                                          gpointer      marshal_data)
268
 
{
269
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED) (gpointer     data1,
270
 
                                                          gpointer     arg_1,
271
 
                                                          gpointer     arg_2,
272
 
                                                          gpointer     data2);
273
 
  register GMarshalFunc_BOOLEAN__OBJECT_BOXED callback;
274
 
  register GCClosure *cc = (GCClosure*) closure;
275
 
  register gpointer data1, data2;
276
 
  gboolean v_return;
277
 
 
278
 
  g_return_if_fail (return_value != NULL);
279
 
  g_return_if_fail (n_param_values == 3);
280
 
 
281
 
  if (G_CCLOSURE_SWAP_DATA (closure))
282
 
    {
283
 
      data1 = closure->data;
284
 
      data2 = g_value_peek_pointer (param_values + 0);
285
 
    }
286
 
  else
287
 
    {
288
 
      data1 = g_value_peek_pointer (param_values + 0);
289
 
      data2 = closure->data;
290
 
    }
291
 
  callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
292
 
 
293
 
  v_return = callback (data1,
294
 
                       g_marshal_value_peek_object (param_values + 1),
295
 
                       g_marshal_value_peek_boxed (param_values + 2),
296
 
                       data2);
297
 
 
298
 
  g_value_set_boolean (return_value, v_return);
299
 
}
300
 
 
301
 
/* BOOLEAN:OBJECT,STRING,UINT (e-gdbus-marshallers.list:10) */
302
 
void
303
 
_e_gdbus_gdbus_cclosure_marshaller_BOOLEAN__OBJECT_STRING_UINT (GClosure     *closure,
304
 
                                                                GValue       *return_value G_GNUC_UNUSED,
305
 
                                                                guint         n_param_values,
306
 
                                                                const GValue *param_values,
307
 
                                                                gpointer      invocation_hint G_GNUC_UNUSED,
308
 
                                                                gpointer      marshal_data)
309
 
{
310
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_UINT) (gpointer     data1,
311
 
                                                                gpointer     arg_1,
312
 
                                                                gpointer     arg_2,
313
 
                                                                guint        arg_3,
314
 
                                                                gpointer     data2);
315
 
  register GMarshalFunc_BOOLEAN__OBJECT_STRING_UINT callback;
316
 
  register GCClosure *cc = (GCClosure*) closure;
317
 
  register gpointer data1, data2;
318
 
  gboolean v_return;
319
 
 
320
 
  g_return_if_fail (return_value != NULL);
321
 
  g_return_if_fail (n_param_values == 4);
322
 
 
323
 
  if (G_CCLOSURE_SWAP_DATA (closure))
324
 
    {
325
 
      data1 = closure->data;
326
 
      data2 = g_value_peek_pointer (param_values + 0);
327
 
    }
328
 
  else
329
 
    {
330
 
      data1 = g_value_peek_pointer (param_values + 0);
331
 
      data2 = closure->data;
332
 
    }
333
 
  callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_UINT) (marshal_data ? marshal_data : cc->callback);
334
 
 
335
 
  v_return = callback (data1,
336
 
                       g_marshal_value_peek_object (param_values + 1),
337
 
                       g_marshal_value_peek_string (param_values + 2),
338
 
                       g_marshal_value_peek_uint (param_values + 3),
339
 
                       data2);
340
 
 
341
 
  g_value_set_boolean (return_value, v_return);
342
 
}
343