gee/functions.c

   1 /* functions.c generated by valac 0.18.0, the Vala compiler
   2  * generated from functions.vala, do not modify */
   3
   4 /* functions.vala
   5  *
   6  * Copyright (C) 2009  Didier Villevalois, Maciej Piechotka
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  21  *
  22  * Author:
  23  *      Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
  24  *      Maciej Piechotka <uzytkownik2@gmail.com>
  25  */
  26
  27 #include <glib.h>
  28 #include <glib-object.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32
  33 #define GEE_TYPE_HASHABLE (gee_hashable_get_type ())
  34 #define GEE_HASHABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_HASHABLE, GeeHashable))
  35 #define GEE_IS_HASHABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_HASHABLE))
  36 #define GEE_HASHABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_HASHABLE, GeeHashableIface))
  37
  38 typedef struct _GeeHashable GeeHashable;
  39 typedef struct _GeeHashableIface GeeHashableIface;
  40
  41 #define GEE_TYPE_COMPARABLE (gee_comparable_get_type ())
  42 #define GEE_COMPARABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COMPARABLE, GeeComparable))
  43 #define GEE_IS_COMPARABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COMPARABLE))
  44 #define GEE_COMPARABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COMPARABLE, GeeComparableIface))
  45
  46 typedef struct _GeeComparable GeeComparable;
  47 typedef struct _GeeComparableIface GeeComparableIface;
  48
  49 typedef gboolean (*GeeEqualDataFunc) (gconstpointer a, gconstpointer b, void* user_data);
  50 struct _GeeHashableIface {
  51         GTypeInterface parent_iface;
  52         guint (*hash) (GeeHashable* self);
  53         gboolean (*equal_to) (GeeHashable* self, gconstpointer object);
  54 };
  55
  56 struct _GeeComparableIface {
  57         GTypeInterface parent_iface;
  58         gint (*compare_to) (GeeComparable* self, gconstpointer object);
  59 };
  60
  61 typedef guint (*GeeHashDataFunc) (gconstpointer v, void* user_data);
  62
  63
  64 GeeEqualDataFunc gee_functions_get_equal_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
  65 static gboolean ___lambda21_ (gconstpointer a, gconstpointer b);
  66 static gboolean ____lambda21__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self);
  67 GType gee_hashable_get_type (void) G_GNUC_CONST;
  68 static gboolean ____lambda22_ (gconstpointer a, gconstpointer b);
  69 gboolean gee_hashable_equal_to (GeeHashable* self, gconstpointer object);
  70 static gboolean _____lambda22__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self);
  71 GType gee_comparable_get_type (void) G_GNUC_CONST;
  72 static gboolean _____lambda23_ (gconstpointer a, gconstpointer b);
  73 gint gee_comparable_compare_to (GeeComparable* self, gconstpointer object);
  74 static gboolean ______lambda23__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self);
  75 static gboolean _____lambda24_ (gconstpointer a, gconstpointer b);
  76 static gboolean ______lambda24__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self);
  77 GeeHashDataFunc gee_functions_get_hash_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
  78 static guint ___lambda18_ (gconstpointer a);
  79 static guint ____lambda18__gee_hash_data_func (gconstpointer v, gpointer self);
  80 static guint ____lambda19_ (gconstpointer a);
  81 guint gee_hashable_hash (GeeHashable* self);
  82 static guint _____lambda19__gee_hash_data_func (gconstpointer v, gpointer self);
  83 static guint ____lambda20_ (gconstpointer a);
  84 static guint _____lambda20__gee_hash_data_func (gconstpointer v, gpointer self);
  85 GCompareDataFunc gee_functions_get_compare_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
  86 static gint ___lambda25_ (gconstpointer a, gconstpointer b);
  87 static gint ____lambda25__gcompare_data_func (gconstpointer a, gconstpointer b, gpointer self);
  88 static gint ____lambda26_ (gconstpointer a, gconstpointer b);
  89 static gint _____lambda26__gcompare_data_func (gconstpointer a, gconstpointer b, gpointer self);
  90 static gint ____lambda27_ (gconstpointer _val1, gconstpointer _val2);
  91 static gint _____lambda27__gcompare_data_func (gconstpointer a, gconstpointer b, gpointer self);
  92
  93
  94 /**
  95  * Get a equality testing function for a given type.
  96  *
  97  * @param t the type which to get an equality testing function for.
  98  *
  99  * @return the equality testing function corresponding to the given type.
 100  */
 101 static gboolean ___lambda21_ (gconstpointer a, gconstpointer b) {
 102         gboolean result = FALSE;
 103         gconstpointer _tmp0_;
 104         gconstpointer _tmp1_;
 105         _tmp0_ = a;
 106         _tmp1_ = b;
 107         if (_tmp0_ == _tmp1_) {
 108                 result = TRUE;
 109                 return result;
 110         } else {
 111                 gboolean _tmp2_ = FALSE;
 112                 gconstpointer _tmp3_;
 113                 gboolean _tmp5_;
 114                 _tmp3_ = a;
 115                 if (_tmp3_ == NULL) {
 116                         _tmp2_ = TRUE;
 117                 } else {
 118                         gconstpointer _tmp4_;
 119                         _tmp4_ = b;
 120                         _tmp2_ = _tmp4_ == NULL;
 121                 }
 122                 _tmp5_ = _tmp2_;
 123                 if (_tmp5_) {
 124                         result = FALSE;
 125                         return result;
 126                 } else {
 127                         GEqualFunc _tmp6_;
 128                         gconstpointer _tmp7_;
 129                         gconstpointer _tmp8_;
 130                         gboolean _tmp9_ = FALSE;
 131                         _tmp6_ = g_str_equal;
 132                         _tmp7_ = a;
 133                         _tmp8_ = b;
 134                         _tmp9_ = _tmp6_ ((const gchar*) _tmp7_, (const gchar*) _tmp8_);
 135                         result = _tmp9_;
 136                         return result;
 137                 }
 138         }
 139 }
 140
 141
 142 static gboolean ____lambda21__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self) {
 143         gboolean result;
 144         result = ___lambda21_ (a, b);
 145         return result;
 146 }
 147
 148
 149 static gboolean ____lambda22_ (gconstpointer a, gconstpointer b) {
 150         gboolean result = FALSE;
 151         gconstpointer _tmp0_;
 152         gconstpointer _tmp1_;
 153         _tmp0_ = a;
 154         _tmp1_ = b;
 155         if (_tmp0_ == _tmp1_) {
 156                 result = TRUE;
 157                 return result;
 158         } else {
 159                 gboolean _tmp2_ = FALSE;
 160                 gconstpointer _tmp3_;
 161                 gboolean _tmp5_;
 162                 _tmp3_ = a;
 163                 if (_tmp3_ == NULL) {
 164                         _tmp2_ = TRUE;
 165                 } else {
 166                         gconstpointer _tmp4_;
 167                         _tmp4_ = b;
 168                         _tmp2_ = _tmp4_ == NULL;
 169                 }
 170                 _tmp5_ = _tmp2_;
 171                 if (_tmp5_) {
 172                         result = FALSE;
 173                         return result;
 174                 } else {
 175                         gconstpointer _tmp6_;
 176                         gconstpointer _tmp7_;
 177                         gboolean _tmp8_ = FALSE;
 178                         _tmp6_ = a;
 179                         _tmp7_ = b;
 180                         _tmp8_ = gee_hashable_equal_to (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, GEE_TYPE_HASHABLE, GeeHashable), G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, GEE_TYPE_HASHABLE, GeeHashable));
 181                         result = _tmp8_;
 182                         return result;
 183                 }
 184         }
 185 }
 186
 187
 188 static gboolean _____lambda22__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self) {
 189         gboolean result;
 190         result = ____lambda22_ (a, b);
 191         return result;
 192 }
 193
 194
 195 static gboolean _____lambda23_ (gconstpointer a, gconstpointer b) {
 196         gboolean result = FALSE;
 197         gconstpointer _tmp0_;
 198         gconstpointer _tmp1_;
 199         _tmp0_ = a;
 200         _tmp1_ = b;
 201         if (_tmp0_ == _tmp1_) {
 202                 result = TRUE;
 203                 return result;
 204         } else {
 205                 gboolean _tmp2_ = FALSE;
 206                 gconstpointer _tmp3_;
 207                 gboolean _tmp5_;
 208                 _tmp3_ = a;
 209                 if (_tmp3_ == NULL) {
 210                         _tmp2_ = TRUE;
 211                 } else {
 212                         gconstpointer _tmp4_;
 213                         _tmp4_ = b;
 214                         _tmp2_ = _tmp4_ == NULL;
 215                 }
 216                 _tmp5_ = _tmp2_;
 217                 if (_tmp5_) {
 218                         result = FALSE;
 219                         return result;
 220                 } else {
 221                         gconstpointer _tmp6_;
 222                         gconstpointer _tmp7_;
 223                         gint _tmp8_ = 0;
 224                         _tmp6_ = a;
 225                         _tmp7_ = b;
 226                         _tmp8_ = gee_comparable_compare_to (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, GEE_TYPE_COMPARABLE, GeeComparable), G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, GEE_TYPE_COMPARABLE, GeeComparable));
 227                         result = _tmp8_ == 0;
 228                         return result;
 229                 }
 230         }
 231 }
 232
 233
 234 static gboolean ______lambda23__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self) {
 235         gboolean result;
 236         result = _____lambda23_ (a, b);
 237         return result;
 238 }
 239
 240
 241 static gboolean _____lambda24_ (gconstpointer a, gconstpointer b) {
 242         gboolean result = FALSE;
 243         GEqualFunc _tmp0_;
 244         gconstpointer _tmp1_;
 245         gconstpointer _tmp2_;
 246         gboolean _tmp3_ = FALSE;
 247         _tmp0_ = g_direct_equal;
 248         _tmp1_ = a;
 249         _tmp2_ = b;
 250         _tmp3_ = _tmp0_ (_tmp1_, _tmp2_);
 251         result = _tmp3_;
 252         return result;
 253 }
 254
 255
 256 static gboolean ______lambda24__gee_equal_data_func (gconstpointer a, gconstpointer b, gpointer self) {
 257         gboolean result;
 258         result = _____lambda24_ (a, b);
 259         return result;
 260 }
 261
 262
 263 GeeEqualDataFunc gee_functions_get_equal_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify) {
 264         GeeEqualDataFunc result = NULL;
 265         GType _tmp0_;
 266         _tmp0_ = t;
 267         if (_tmp0_ == G_TYPE_STRING) {
 268                 GeeEqualDataFunc _tmp1_;
 269                 void* _tmp1__target;
 270                 GDestroyNotify _tmp1__target_destroy_notify;
 271                 _tmp1_ = ____lambda21__gee_equal_data_func;
 272                 _tmp1__target = NULL;
 273                 _tmp1__target_destroy_notify = NULL;
 274                 *result_target = _tmp1__target;
 275                 *result_target_destroy_notify = _tmp1__target_destroy_notify;
 276                 result = _tmp1_;
 277                 return result;
 278         } else {
 279                 GType _tmp2_;
 280                 gboolean _tmp3_ = FALSE;
 281                 _tmp2_ = t;
 282                 _tmp3_ = g_type_is_a (_tmp2_, GEE_TYPE_HASHABLE);
 283                 if (_tmp3_) {
 284                         GeeEqualDataFunc _tmp4_;
 285                         void* _tmp4__target;
 286                         GDestroyNotify _tmp4__target_destroy_notify;
 287                         _tmp4_ = _____lambda22__gee_equal_data_func;
 288                         _tmp4__target = NULL;
 289                         _tmp4__target_destroy_notify = NULL;
 290                         *result_target = _tmp4__target;
 291                         *result_target_destroy_notify = _tmp4__target_destroy_notify;
 292                         result = _tmp4_;
 293                         return result;
 294                 } else {
 295                         GType _tmp5_;
 296                         gboolean _tmp6_ = FALSE;
 297                         _tmp5_ = t;
 298                         _tmp6_ = g_type_is_a (_tmp5_, GEE_TYPE_COMPARABLE);
 299                         if (_tmp6_) {
 300                                 GeeEqualDataFunc _tmp7_;
 301                                 void* _tmp7__target;
 302                                 GDestroyNotify _tmp7__target_destroy_notify;
 303                                 _tmp7_ = ______lambda23__gee_equal_data_func;
 304                                 _tmp7__target = NULL;
 305                                 _tmp7__target_destroy_notify = NULL;
 306                                 *result_target = _tmp7__target;
 307                                 *result_target_destroy_notify = _tmp7__target_destroy_notify;
 308                                 result = _tmp7_;
 309                                 return result;
 310                         } else {
 311                                 GeeEqualDataFunc _tmp8_;
 312                                 void* _tmp8__target;
 313                                 GDestroyNotify _tmp8__target_destroy_notify;
 314                                 _tmp8_ = ______lambda24__gee_equal_data_func;
 315                                 _tmp8__target = NULL;
 316                                 _tmp8__target_destroy_notify = NULL;
 317                                 *result_target = _tmp8__target;
 318                                 *result_target_destroy_notify = _tmp8__target_destroy_notify;
 319                                 result = _tmp8_;
 320                                 return result;
 321                         }
 322                 }
 323         }
 324 }
 325
 326
 327 /**
 328  * Get a hash function for a given type.
 329  *
 330  * @param t the type which to get the hash function for.
 331  *
 332  * @return the hash function corresponding to the given type.
 333  */
 334 static guint ___lambda18_ (gconstpointer a) {
 335         guint result = 0U;
 336         gconstpointer _tmp0_;
 337         _tmp0_ = a;
 338         if (_tmp0_ == NULL) {
 339                 result = (guint) 0xdeadbeefLL;
 340                 return result;
 341         } else {
 342                 GHashFunc _tmp1_;
 343                 gconstpointer _tmp2_;
 344                 guint _tmp3_ = 0U;
 345                 _tmp1_ = g_str_hash;
 346                 _tmp2_ = a;
 347                 _tmp3_ = _tmp1_ ((const gchar*) _tmp2_);
 348                 result = _tmp3_;
 349                 return result;
 350         }
 351 }
 352
 353
 354 static guint ____lambda18__gee_hash_data_func (gconstpointer v, gpointer self) {
 355         guint result;
 356         result = ___lambda18_ (v);
 357         return result;
 358 }
 359
 360
 361 static guint ____lambda19_ (gconstpointer a) {
 362         guint result = 0U;
 363         gconstpointer _tmp0_;
 364         _tmp0_ = a;
 365         if (_tmp0_ == NULL) {
 366                 result = (guint) 0xdeadbeefLL;
 367                 return result;
 368         } else {
 369                 gconstpointer _tmp1_;
 370                 guint _tmp2_ = 0U;
 371                 _tmp1_ = a;
 372                 _tmp2_ = gee_hashable_hash (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, GEE_TYPE_HASHABLE, GeeHashable));
 373                 result = _tmp2_;
 374                 return result;
 375         }
 376 }
 377
 378
 379 static guint _____lambda19__gee_hash_data_func (gconstpointer v, gpointer self) {
 380         guint result;
 381         result = ____lambda19_ (v);
 382         return result;
 383 }
 384
 385
 386 static guint ____lambda20_ (gconstpointer a) {
 387         guint result = 0U;
 388         GHashFunc _tmp0_;
 389         gconstpointer _tmp1_;
 390         guint _tmp2_ = 0U;
 391         _tmp0_ = g_direct_hash;
 392         _tmp1_ = a;
 393         _tmp2_ = _tmp0_ (_tmp1_);
 394         result = _tmp2_;
 395         return result;
 396 }
 397
 398
 399 static guint _____lambda20__gee_hash_data_func (gconstpointer v, gpointer self) {
 400         guint result;
 401         result = ____lambda20_ (v);
 402         return result;
 403 }
 404
 405
 406 GeeHashDataFunc gee_functions_get_hash_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify) {
 407         GeeHashDataFunc result = NULL;
 408         GType _tmp0_;
 409         _tmp0_ = t;
 410         if (_tmp0_ == G_TYPE_STRING) {
 411                 GeeHashDataFunc _tmp1_;
 412                 void* _tmp1__target;
 413                 GDestroyNotify _tmp1__target_destroy_notify;
 414                 _tmp1_ = ____lambda18__gee_hash_data_func;
 415                 _tmp1__target = NULL;
 416                 _tmp1__target_destroy_notify = NULL;
 417                 *result_target = _tmp1__target;
 418                 *result_target_destroy_notify = _tmp1__target_destroy_notify;
 419                 result = _tmp1_;
 420                 return result;
 421         } else {
 422                 GType _tmp2_;
 423                 gboolean _tmp3_ = FALSE;
 424                 _tmp2_ = t;
 425                 _tmp3_ = g_type_is_a (_tmp2_, GEE_TYPE_HASHABLE);
 426                 if (_tmp3_) {
 427                         GeeHashDataFunc _tmp4_;
 428                         void* _tmp4__target;
 429                         GDestroyNotify _tmp4__target_destroy_notify;
 430                         _tmp4_ = _____lambda19__gee_hash_data_func;
 431                         _tmp4__target = NULL;
 432                         _tmp4__target_destroy_notify = NULL;
 433                         *result_target = _tmp4__target;
 434                         *result_target_destroy_notify = _tmp4__target_destroy_notify;
 435                         result = _tmp4_;
 436                         return result;
 437                 } else {
 438                         GeeHashDataFunc _tmp5_;
 439                         void* _tmp5__target;
 440                         GDestroyNotify _tmp5__target_destroy_notify;
 441                         _tmp5_ = _____lambda20__gee_hash_data_func;
 442                         _tmp5__target = NULL;
 443                         _tmp5__target_destroy_notify = NULL;
 444                         *result_target = _tmp5__target;
 445                         *result_target_destroy_notify = _tmp5__target_destroy_notify;
 446                         result = _tmp5_;
 447                         return result;
 448                 }
 449         }
 450 }
 451
 452
 453 /**
 454  * Get a comparator function for a given type.
 455  *
 456  * @param t the type which to get a comparator function for.
 457  *
 458  * @return the comparator function corresponding to the given type.
 459  */
 460 static gint ___lambda25_ (gconstpointer a, gconstpointer b) {
 461         gint result = 0;
 462         gconstpointer _tmp0_;
 463         gconstpointer _tmp1_;
 464         _tmp0_ = a;
 465         _tmp1_ = b;
 466         if (_tmp0_ == _tmp1_) {
 467                 result = 0;
 468                 return result;
 469         } else {
 470                 gconstpointer _tmp2_;
 471                 _tmp2_ = a;
 472                 if (_tmp2_ == NULL) {
 473                         result = -1;
 474                         return result;
 475                 } else {
 476                         gconstpointer _tmp3_;
 477                         _tmp3_ = b;
 478                         if (_tmp3_ == NULL) {
 479                                 result = 1;
 480                                 return result;
 481                         } else {
 482                                 GCompareFunc _tmp4_;
 483                                 gconstpointer _tmp5_;
 484                                 gconstpointer _tmp6_;
 485                                 gint _tmp7_ = 0;
 486                                 _tmp4_ = g_strcmp0;
 487                                 _tmp5_ = a;
 488                                 _tmp6_ = b;
 489                                 _tmp7_ = _tmp4_ ((const gchar*) _tmp5_, (const gchar*) _tmp6_);
 490                                 result = _tmp7_;
 491                                 return result;
 492                         }
 493                 }
 494         }
 495 }
 496
 497
 498 static gint ____lambda25__gcompare_data_func (gconstpointer a, gconstpointer b, gpointer self) {
 499         gint result;
 500         result = ___lambda25_ (a, b);
 501         return result;
 502 }
 503
 504
 505 static gint ____lambda26_ (gconstpointer a, gconstpointer b) {
 506         gint result = 0;
 507         gconstpointer _tmp0_;
 508         gconstpointer _tmp1_;
 509         _tmp0_ = a;
 510         _tmp1_ = b;
 511         if (_tmp0_ == _tmp1_) {
 512                 result = 0;
 513                 return result;
 514         } else {
 515                 gconstpointer _tmp2_;
 516                 _tmp2_ = a;
 517                 if (_tmp2_ == NULL) {
 518                         result = -1;
 519                         return result;
 520                 } else {
 521                         gconstpointer _tmp3_;
 522                         _tmp3_ = b;
 523                         if (_tmp3_ == NULL) {
 524                                 result = 1;
 525                                 return result;
 526                         } else {
 527                                 gconstpointer _tmp4_;
 528                                 gconstpointer _tmp5_;
 529                                 gint _tmp6_ = 0;
 530                                 _tmp4_ = a;
 531                                 _tmp5_ = b;
 532                                 _tmp6_ = gee_comparable_compare_to (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, GEE_TYPE_COMPARABLE, GeeComparable), G_TYPE_CHECK_INSTANCE_CAST (_tmp5_, GEE_TYPE_COMPARABLE, GeeComparable));
 533                                 result = _tmp6_;
 534                                 return result;
 535                         }
 536                 }
 537         }
 538 }
 539
 540
 541 static gint _____lambda26__gcompare_data_func (gconstpointer a, gconstpointer b, gpointer self) {
 542         gint result;
 543         result = ____lambda26_ (a, b);
 544         return result;
 545 }
 546
 547
 548 static gint ____lambda27_ (gconstpointer _val1, gconstpointer _val2) {
 549         gint result = 0;
 550         gconstpointer _tmp0_;
 551         glong val1;
 552         gconstpointer _tmp1_;
 553         glong val2;
 554         glong _tmp2_;
 555         glong _tmp3_;
 556         _tmp0_ = _val1;
 557         val1 = (glong) _tmp0_;
 558         _tmp1_ = _val2;
 559         val2 = (glong) _tmp1_;
 560         _tmp2_ = val1;
 561         _tmp3_ = val2;
 562         if (_tmp2_ > _tmp3_) {
 563                 result = 1;
 564                 return result;
 565         } else {
 566                 glong _tmp4_;
 567                 glong _tmp5_;
 568                 _tmp4_ = val1;
 569                 _tmp5_ = val2;
 570                 if (_tmp4_ == _tmp5_) {
 571                         result = 0;
 572                         return result;
 573                 } else {
 574                         result = -1;
 575                         return result;
 576                 }
 577         }
 578 }
 579
 580
 581 static gint _____lambda27__gcompare_data_func (gconstpointer a, gconstpointer b, gpointer self) {
 582         gint result;
 583         result = ____lambda27_ (a, b);
 584         return result;
 585 }
 586
 587
 588 GCompareDataFunc gee_functions_get_compare_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify) {
 589         GCompareDataFunc result = NULL;
 590         GType _tmp0_;
 591         _tmp0_ = t;
 592         if (_tmp0_ == G_TYPE_STRING) {
 593                 GCompareDataFunc _tmp1_;
 594                 void* _tmp1__target;
 595                 GDestroyNotify _tmp1__target_destroy_notify;
 596                 _tmp1_ = ____lambda25__gcompare_data_func;
 597                 _tmp1__target = NULL;
 598                 _tmp1__target_destroy_notify = NULL;
 599                 *result_target = _tmp1__target;
 600                 *result_target_destroy_notify = _tmp1__target_destroy_notify;
 601                 result = _tmp1_;
 602                 return result;
 603         } else {
 604                 GType _tmp2_;
 605                 gboolean _tmp3_ = FALSE;
 606                 _tmp2_ = t;
 607                 _tmp3_ = g_type_is_a (_tmp2_, GEE_TYPE_COMPARABLE);
 608                 if (_tmp3_) {
 609                         GCompareDataFunc _tmp4_;
 610                         void* _tmp4__target;
 611                         GDestroyNotify _tmp4__target_destroy_notify;
 612                         _tmp4_ = _____lambda26__gcompare_data_func;
 613                         _tmp4__target = NULL;
 614                         _tmp4__target_destroy_notify = NULL;
 615                         *result_target = _tmp4__target;
 616                         *result_target_destroy_notify = _tmp4__target_destroy_notify;
 617                         result = _tmp4_;
 618                         return result;
 619                 } else {
 620                         GCompareDataFunc _tmp5_;
 621                         void* _tmp5__target;
 622                         GDestroyNotify _tmp5__target_destroy_notify;
 623                         _tmp5_ = _____lambda27__gcompare_data_func;
 624                         _tmp5__target = NULL;
 625                         _tmp5__target_destroy_notify = NULL;
 626                         *result_target = _tmp5__target;
 627                         *result_target_destroy_notify = _tmp5__target_destroy_notify;
 628                         result = _tmp5_;
 629                         return result;
 630                 }
 631         }
 632 }
 633
 634
 635