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

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