git.sur5r.net Git - bacula/bacula/blob - bacula/src/tray-monitor/eggmarshalers.c

   1 extern "C" {
   2
   3 #include <glib-object.h>
   4
   5
   6 #ifdef G_ENABLE_DEBUG
   7 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
   8 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
   9 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  10 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  11 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  12 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  13 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  14 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  15 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  16 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  17 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  18 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  19 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  20 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  21 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  22 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  23 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  24 #define g_marshal_value_peek_object(v)   g_value_get_object (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_int
  40 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_uint
  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 #endif /* !G_ENABLE_DEBUG */
  49
  50
  51 /* VOID:OBJECT,OBJECT (eggmarshalers.list:1) */
  52 void
  53 _egg_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
  54                                   GValue       *return_value,
  55                                   guint         n_param_values,
  56                                   const GValue *param_values,
  57                                   gpointer      invocation_hint,
  58                                   gpointer      marshal_data)
  59 {
  60   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
  61                                                     gpointer     arg_1,
  62                                                     gpointer     arg_2,
  63                                                     gpointer     data2);
  64   register GMarshalFunc_VOID__OBJECT_OBJECT callback;
  65   register GCClosure *cc = (GCClosure*) closure;
  66   register gpointer data1, data2;
  67
  68   g_return_if_fail (n_param_values == 3);
  69
  70   if (G_CCLOSURE_SWAP_DATA (closure))
  71     {
  72       data1 = closure->data;
  73       data2 = g_value_peek_pointer (param_values + 0);
  74     }
  75   else
  76     {
  77       data1 = g_value_peek_pointer (param_values + 0);
  78       data2 = closure->data;
  79     }
  80   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
  81
  82   callback (data1,
  83             g_marshal_value_peek_object (param_values + 1),
  84             g_marshal_value_peek_object (param_values + 2),
  85             data2);
  86 }
  87
  88 /* VOID:OBJECT,STRING,LONG,LONG (eggmarshalers.list:2) */
  89 void
  90 _egg_marshal_VOID__OBJECT_STRING_LONG_LONG (GClosure     *closure,
  91                                             GValue       *return_value,
  92                                             guint         n_param_values,
  93                                             const GValue *param_values,
  94                                             gpointer      invocation_hint,
  95                                             gpointer      marshal_data)
  96 {
  97   typedef void (*GMarshalFunc_VOID__OBJECT_STRING_LONG_LONG) (gpointer     data1,
  98                                                               gpointer     arg_1,
  99                                                               gpointer     arg_2,
 100                                                               glong        arg_3,
 101                                                               glong        arg_4,
 102                                                               gpointer     data2);
 103   register GMarshalFunc_VOID__OBJECT_STRING_LONG_LONG callback;
 104   register GCClosure *cc = (GCClosure*) closure;
 105   register gpointer data1, data2;
 106
 107   g_return_if_fail (n_param_values == 5);
 108
 109   if (G_CCLOSURE_SWAP_DATA (closure))
 110     {
 111       data1 = closure->data;
 112       data2 = g_value_peek_pointer (param_values + 0);
 113     }
 114   else
 115     {
 116       data1 = g_value_peek_pointer (param_values + 0);
 117       data2 = closure->data;
 118     }
 119   callback = (GMarshalFunc_VOID__OBJECT_STRING_LONG_LONG) (marshal_data ? marshal_data : cc->callback);
 120
 121   callback (data1,
 122             g_marshal_value_peek_object (param_values + 1),
 123             g_marshal_value_peek_string (param_values + 2),
 124             g_marshal_value_peek_long (param_values + 3),
 125             g_marshal_value_peek_long (param_values + 4),
 126             data2);
 127 }
 128
 129 /* VOID:OBJECT,LONG (eggmarshalers.list:3) */
 130 void
 131 _egg_marshal_VOID__OBJECT_LONG (GClosure     *closure,
 132                                 GValue       *return_value,
 133                                 guint         n_param_values,
 134                                 const GValue *param_values,
 135                                 gpointer      invocation_hint,
 136                                 gpointer      marshal_data)
 137 {
 138   typedef void (*GMarshalFunc_VOID__OBJECT_LONG) (gpointer     data1,
 139                                                   gpointer     arg_1,
 140                                                   glong        arg_2,
 141                                                   gpointer     data2);
 142   register GMarshalFunc_VOID__OBJECT_LONG callback;
 143   register GCClosure *cc = (GCClosure*) closure;
 144   register gpointer data1, data2;
 145
 146   g_return_if_fail (n_param_values == 3);
 147
 148   if (G_CCLOSURE_SWAP_DATA (closure))
 149     {
 150       data1 = closure->data;
 151       data2 = g_value_peek_pointer (param_values + 0);
 152     }
 153   else
 154     {
 155       data1 = g_value_peek_pointer (param_values + 0);
 156       data2 = closure->data;
 157     }
 158   callback = (GMarshalFunc_VOID__OBJECT_LONG) (marshal_data ? marshal_data : cc->callback);
 159
 160   callback (data1,
 161             g_marshal_value_peek_object (param_values + 1),
 162             g_marshal_value_peek_long (param_values + 2),
 163             data2);
 164 }
 165
 166 /* VOID:OBJECT,STRING,STRING (eggmarshalers.list:4) */
 167 void
 168 _egg_marshal_VOID__OBJECT_STRING_STRING (GClosure     *closure,
 169                                          GValue       *return_value,
 170                                          guint         n_param_values,
 171                                          const GValue *param_values,
 172                                          gpointer      invocation_hint,
 173                                          gpointer      marshal_data)
 174 {
 175   typedef void (*GMarshalFunc_VOID__OBJECT_STRING_STRING) (gpointer     data1,
 176                                                            gpointer     arg_1,
 177                                                            gpointer     arg_2,
 178                                                            gpointer     arg_3,
 179                                                            gpointer     data2);
 180   register GMarshalFunc_VOID__OBJECT_STRING_STRING callback;
 181   register GCClosure *cc = (GCClosure*) closure;
 182   register gpointer data1, data2;
 183
 184   g_return_if_fail (n_param_values == 4);
 185
 186   if (G_CCLOSURE_SWAP_DATA (closure))
 187     {
 188       data1 = closure->data;
 189       data2 = g_value_peek_pointer (param_values + 0);
 190     }
 191   else
 192     {
 193       data1 = g_value_peek_pointer (param_values + 0);
 194       data2 = closure->data;
 195     }
 196   callback = (GMarshalFunc_VOID__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 197
 198   callback (data1,
 199             g_marshal_value_peek_object (param_values + 1),
 200             g_marshal_value_peek_string (param_values + 2),
 201             g_marshal_value_peek_string (param_values + 3),
 202             data2);
 203 }
 204
 205 /* VOID:UINT,UINT (eggmarshalers.list:5) */
 206 void
 207 _egg_marshal_VOID__UINT_UINT (GClosure     *closure,
 208                               GValue       *return_value,
 209                               guint         n_param_values,
 210                               const GValue *param_values,
 211                               gpointer      invocation_hint,
 212                               gpointer      marshal_data)
 213 {
 214   typedef void (*GMarshalFunc_VOID__UINT_UINT) (gpointer     data1,
 215                                                 guint        arg_1,
 216                                                 guint        arg_2,
 217                                                 gpointer     data2);
 218   register GMarshalFunc_VOID__UINT_UINT callback;
 219   register GCClosure *cc = (GCClosure*) closure;
 220   register gpointer data1, data2;
 221
 222   g_return_if_fail (n_param_values == 3);
 223
 224   if (G_CCLOSURE_SWAP_DATA (closure))
 225     {
 226       data1 = closure->data;
 227       data2 = g_value_peek_pointer (param_values + 0);
 228     }
 229   else
 230     {
 231       data1 = g_value_peek_pointer (param_values + 0);
 232       data2 = closure->data;
 233     }
 234   callback = (GMarshalFunc_VOID__UINT_UINT) (marshal_data ? marshal_data : cc->callback);
 235
 236   callback (data1,
 237             g_marshal_value_peek_uint (param_values + 1),
 238             g_marshal_value_peek_uint (param_values + 2),
 239             data2);
 240 }
 241
 242 /* BOOLEAN:INT (eggmarshalers.list:6) */
 243 void
 244 _egg_marshal_BOOLEAN__INT (GClosure     *closure,
 245                            GValue       *return_value,
 246                            guint         n_param_values,
 247                            const GValue *param_values,
 248                            gpointer      invocation_hint,
 249                            gpointer      marshal_data)
 250 {
 251   typedef gboolean (*GMarshalFunc_BOOLEAN__INT) (gpointer     data1,
 252                                                  gint         arg_1,
 253                                                  gpointer     data2);
 254   register GMarshalFunc_BOOLEAN__INT callback;
 255   register GCClosure *cc = (GCClosure*) closure;
 256   register gpointer data1, data2;
 257   gboolean v_return;
 258
 259   g_return_if_fail (return_value != NULL);
 260   g_return_if_fail (n_param_values == 2);
 261
 262   if (G_CCLOSURE_SWAP_DATA (closure))
 263     {
 264       data1 = closure->data;
 265       data2 = g_value_peek_pointer (param_values + 0);
 266     }
 267   else
 268     {
 269       data1 = g_value_peek_pointer (param_values + 0);
 270       data2 = closure->data;
 271     }
 272   callback = (GMarshalFunc_BOOLEAN__INT) (marshal_data ? marshal_data : cc->callback);
 273
 274   v_return = callback (data1,
 275                        g_marshal_value_peek_int (param_values + 1),
 276                        data2);
 277
 278   g_value_set_boolean (return_value, v_return);
 279 }
 280
 281 /* BOOLEAN:ENUM (eggmarshalers.list:7) */
 282 void
 283 _egg_marshal_BOOLEAN__ENUM (GClosure     *closure,
 284                             GValue       *return_value,
 285                             guint         n_param_values,
 286                             const GValue *param_values,
 287                             gpointer      invocation_hint,
 288                             gpointer      marshal_data)
 289 {
 290   typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM) (gpointer     data1,
 291                                                   gint         arg_1,
 292                                                   gpointer     data2);
 293   register GMarshalFunc_BOOLEAN__ENUM callback;
 294   register GCClosure *cc = (GCClosure*) closure;
 295   register gpointer data1, data2;
 296   gboolean v_return;
 297
 298   g_return_if_fail (return_value != NULL);
 299   g_return_if_fail (n_param_values == 2);
 300
 301   if (G_CCLOSURE_SWAP_DATA (closure))
 302     {
 303       data1 = closure->data;
 304       data2 = g_value_peek_pointer (param_values + 0);
 305     }
 306   else
 307     {
 308       data1 = g_value_peek_pointer (param_values + 0);
 309       data2 = closure->data;
 310     }
 311   callback = (GMarshalFunc_BOOLEAN__ENUM) (marshal_data ? marshal_data : cc->callback);
 312
 313   v_return = callback (data1,
 314                        g_marshal_value_peek_enum (param_values + 1),
 315                        data2);
 316
 317   g_value_set_boolean (return_value, v_return);
 318 }
 319
 320 /* BOOLEAN:VOID (eggmarshalers.list:8) */
 321 void
 322 _egg_marshal_BOOLEAN__VOID (GClosure     *closure,
 323                             GValue       *return_value,
 324                             guint         n_param_values,
 325                             const GValue *param_values,
 326                             gpointer      invocation_hint,
 327                             gpointer      marshal_data)
 328 {
 329   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
 330                                                   gpointer     data2);
 331   register GMarshalFunc_BOOLEAN__VOID callback;
 332   register GCClosure *cc = (GCClosure*) closure;
 333   register gpointer data1, data2;
 334   gboolean v_return;
 335
 336   g_return_if_fail (return_value != NULL);
 337   g_return_if_fail (n_param_values == 1);
 338
 339   if (G_CCLOSURE_SWAP_DATA (closure))
 340     {
 341       data1 = closure->data;
 342       data2 = g_value_peek_pointer (param_values + 0);
 343     }
 344   else
 345     {
 346       data1 = g_value_peek_pointer (param_values + 0);
 347       data2 = closure->data;
 348     }
 349   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 350
 351   v_return = callback (data1,
 352                        data2);
 353
 354   g_value_set_boolean (return_value, v_return);
 355 }
 356
 357 /* OBJECT:VOID (eggmarshalers.list:9) */
 358 void
 359 _egg_marshal_OBJECT__VOID (GClosure     *closure,
 360                            GValue       *return_value,
 361                            guint         n_param_values,
 362                            const GValue *param_values,
 363                            gpointer      invocation_hint,
 364                            gpointer      marshal_data)
 365 {
 366   typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer     data1,
 367                                                  gpointer     data2);
 368   register GMarshalFunc_OBJECT__VOID callback;
 369   register GCClosure *cc = (GCClosure*) closure;
 370   register gpointer data1, data2;
 371   GObject* v_return;
 372
 373   g_return_if_fail (return_value != NULL);
 374   g_return_if_fail (n_param_values == 1);
 375
 376   if (G_CCLOSURE_SWAP_DATA (closure))
 377     {
 378       data1 = closure->data;
 379       data2 = g_value_peek_pointer (param_values + 0);
 380     }
 381   else
 382     {
 383       data1 = g_value_peek_pointer (param_values + 0);
 384       data2 = closure->data;
 385     }
 386   callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
 387
 388   v_return = callback (data1,
 389                        data2);
 390
 391   g_value_set_object_take_ownership (return_value, v_return);
 392 }
 393
 394 /* VOID:VOID (eggmarshalers.list:10) */
 395
 396 /* VOID:INT,INT (eggmarshalers.list:11) */
 397 void
 398 _egg_marshal_VOID__INT_INT (GClosure     *closure,
 399                             GValue       *return_value,
 400                             guint         n_param_values,
 401                             const GValue *param_values,
 402                             gpointer      invocation_hint,
 403                             gpointer      marshal_data)
 404 {
 405   typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer     data1,
 406                                               gint         arg_1,
 407                                               gint         arg_2,
 408                                               gpointer     data2);
 409   register GMarshalFunc_VOID__INT_INT callback;
 410   register GCClosure *cc = (GCClosure*) closure;
 411   register gpointer data1, data2;
 412
 413   g_return_if_fail (n_param_values == 3);
 414
 415   if (G_CCLOSURE_SWAP_DATA (closure))
 416     {
 417       data1 = closure->data;
 418       data2 = g_value_peek_pointer (param_values + 0);
 419     }
 420   else
 421     {
 422       data1 = g_value_peek_pointer (param_values + 0);
 423       data2 = closure->data;
 424     }
 425   callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
 426
 427   callback (data1,
 428             g_marshal_value_peek_int (param_values + 1),
 429             g_marshal_value_peek_int (param_values + 2),
 430             data2);
 431 }
 432
 433 /* VOID:UINT,UINT (eggmarshalers.list:12) */
 434
 435 /* VOID:BOOLEAN (eggmarshalers.list:13) */
 436
 437 /* VOID:OBJECT,ENUM,BOXED (eggmarshalers.list:14) */
 438 void
 439 _egg_marshal_VOID__OBJECT_ENUM_BOXED (GClosure     *closure,
 440                                       GValue       *return_value,
 441                                       guint         n_param_values,
 442                                       const GValue *param_values,
 443                                       gpointer      invocation_hint,
 444                                       gpointer      marshal_data)
 445 {
 446   typedef void (*GMarshalFunc_VOID__OBJECT_ENUM_BOXED) (gpointer     data1,
 447                                                         gpointer     arg_1,
 448                                                         gint         arg_2,
 449                                                         gpointer     arg_3,
 450                                                         gpointer     data2);
 451   register GMarshalFunc_VOID__OBJECT_ENUM_BOXED callback;
 452   register GCClosure *cc = (GCClosure*) closure;
 453   register gpointer data1, data2;
 454
 455   g_return_if_fail (n_param_values == 4);
 456
 457   if (G_CCLOSURE_SWAP_DATA (closure))
 458     {
 459       data1 = closure->data;
 460       data2 = g_value_peek_pointer (param_values + 0);
 461     }
 462   else
 463     {
 464       data1 = g_value_peek_pointer (param_values + 0);
 465       data2 = closure->data;
 466     }
 467   callback = (GMarshalFunc_VOID__OBJECT_ENUM_BOXED) (marshal_data ? marshal_data : cc->callback);
 468
 469   callback (data1,
 470             g_marshal_value_peek_object (param_values + 1),
 471             g_marshal_value_peek_enum (param_values + 2),
 472             g_marshal_value_peek_boxed (param_values + 3),
 473             data2);
 474 }
 475
 476 /* VOID:BOXED (eggmarshalers.list:15) */
 477
 478 /* BOOLEAN:BOOLEAN (eggmarshalers.list:16) */
 479 void
 480 _egg_marshal_BOOLEAN__BOOLEAN (GClosure     *closure,
 481                                GValue       *return_value,
 482                                guint         n_param_values,
 483                                const GValue *param_values,
 484                                gpointer      invocation_hint,
 485                                gpointer      marshal_data)
 486 {
 487   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN) (gpointer     data1,
 488                                                      gboolean     arg_1,
 489                                                      gpointer     data2);
 490   register GMarshalFunc_BOOLEAN__BOOLEAN callback;
 491   register GCClosure *cc = (GCClosure*) closure;
 492   register gpointer data1, data2;
 493   gboolean v_return;
 494
 495   g_return_if_fail (return_value != NULL);
 496   g_return_if_fail (n_param_values == 2);
 497
 498   if (G_CCLOSURE_SWAP_DATA (closure))
 499     {
 500       data1 = closure->data;
 501       data2 = g_value_peek_pointer (param_values + 0);
 502     }
 503   else
 504     {
 505       data1 = g_value_peek_pointer (param_values + 0);
 506       data2 = closure->data;
 507     }
 508   callback = (GMarshalFunc_BOOLEAN__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 509
 510   v_return = callback (data1,
 511                        g_marshal_value_peek_boolean (param_values + 1),
 512                        data2);
 513
 514   g_value_set_boolean (return_value, v_return);
 515 }
 516
 517 /* BOOLEAN:OBJECT,STRING,STRING (eggmarshalers.list:17) */
 518 void
 519 _egg_marshal_BOOLEAN__OBJECT_STRING_STRING (GClosure     *closure,
 520                                             GValue       *return_value,
 521                                             guint         n_param_values,
 522                                             const GValue *param_values,
 523                                             gpointer      invocation_hint,
 524                                             gpointer      marshal_data)
 525 {
 526   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (gpointer     data1,
 527                                                                   gpointer     arg_1,
 528                                                                   gpointer     arg_2,
 529                                                                   gpointer     arg_3,
 530                                                                   gpointer     data2);
 531   register GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING callback;
 532   register GCClosure *cc = (GCClosure*) closure;
 533   register gpointer data1, data2;
 534   gboolean v_return;
 535
 536   g_return_if_fail (return_value != NULL);
 537   g_return_if_fail (n_param_values == 4);
 538
 539   if (G_CCLOSURE_SWAP_DATA (closure))
 540     {
 541       data1 = closure->data;
 542       data2 = g_value_peek_pointer (param_values + 0);
 543     }
 544   else
 545     {
 546       data1 = g_value_peek_pointer (param_values + 0);
 547       data2 = closure->data;
 548     }
 549   callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 550
 551   v_return = callback (data1,
 552                        g_marshal_value_peek_object (param_values + 1),
 553                        g_marshal_value_peek_string (param_values + 2),
 554                        g_marshal_value_peek_string (param_values + 3),
 555                        data2);
 556
 557   g_value_set_boolean (return_value, v_return);
 558 }
 559
 560 } // extern "C"