gee/treeset.c

   1 /* treeset.c generated by valac 0.18.0, the Vala compiler
   2  * generated from treeset.vala, do not modify */
   3
   4 /* treeset.vala
   5  *
   6  * Copyright (C) 2009  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  *      Maciej Piechotka <uzytkownik2@gmail.com>
  24  */
  25
  26 #include <glib.h>
  27 #include <glib-object.h>
  28 #include <gobject/gvaluecollector.h>
  29
  30
  31 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  32 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  33 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  34 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  35
  36 typedef struct _GeeIterable GeeIterable;
  37 typedef struct _GeeIterableIface GeeIterableIface;
  38
  39 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  40 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  41 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  42 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  43
  44 typedef struct _GeeIterator GeeIterator;
  45 typedef struct _GeeIteratorIface GeeIteratorIface;
  46
  47 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  48 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  49 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  50 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  51
  52 typedef struct _GeeCollection GeeCollection;
  53 typedef struct _GeeCollectionIface GeeCollectionIface;
  54
  55 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
  56 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
  57 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  58 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
  59 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
  60 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  61
  62 typedef struct _GeeAbstractCollection GeeAbstractCollection;
  63 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
  64 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
  65
  66 #define GEE_TYPE_SET (gee_set_get_type ())
  67 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
  68 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
  69 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
  70
  71 typedef struct _GeeSet GeeSet;
  72 typedef struct _GeeSetIface GeeSetIface;
  73
  74 #define GEE_TYPE_ABSTRACT_SET (gee_abstract_set_get_type ())
  75 #define GEE_ABSTRACT_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_SET, GeeAbstractSet))
  76 #define GEE_ABSTRACT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_SET, GeeAbstractSetClass))
  77 #define GEE_IS_ABSTRACT_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_SET))
  78 #define GEE_IS_ABSTRACT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_SET))
  79 #define GEE_ABSTRACT_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_SET, GeeAbstractSetClass))
  80
  81 typedef struct _GeeAbstractSet GeeAbstractSet;
  82 typedef struct _GeeAbstractSetClass GeeAbstractSetClass;
  83 typedef struct _GeeAbstractSetPrivate GeeAbstractSetPrivate;
  84
  85 #define GEE_TYPE_SORTED_SET (gee_sorted_set_get_type ())
  86 #define GEE_SORTED_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SORTED_SET, GeeSortedSet))
  87 #define GEE_IS_SORTED_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SORTED_SET))
  88 #define GEE_SORTED_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SORTED_SET, GeeSortedSetIface))
  89
  90 typedef struct _GeeSortedSet GeeSortedSet;
  91 typedef struct _GeeSortedSetIface GeeSortedSetIface;
  92
  93 #define GEE_TYPE_BIDIR_ITERATOR (gee_bidir_iterator_get_type ())
  94 #define GEE_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIterator))
  95 #define GEE_IS_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_BIDIR_ITERATOR))
  96 #define GEE_BIDIR_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIteratorIface))
  97
  98 typedef struct _GeeBidirIterator GeeBidirIterator;
  99 typedef struct _GeeBidirIteratorIface GeeBidirIteratorIface;
 100
 101 #define GEE_TYPE_TREE_SET (gee_tree_set_get_type ())
 102 #define GEE_TREE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TREE_SET, GeeTreeSet))
 103 #define GEE_TREE_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_TREE_SET, GeeTreeSetClass))
 104 #define GEE_IS_TREE_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TREE_SET))
 105 #define GEE_IS_TREE_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_TREE_SET))
 106 #define GEE_TREE_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_TREE_SET, GeeTreeSetClass))
 107
 108 typedef struct _GeeTreeSet GeeTreeSet;
 109 typedef struct _GeeTreeSetClass GeeTreeSetClass;
 110 typedef struct _GeeTreeSetPrivate GeeTreeSetPrivate;
 111 typedef struct _GeeTreeSetNode GeeTreeSetNode;
 112
 113 #define GEE_TREE_SET_TYPE_RANGE_TYPE (gee_tree_set_range_type_get_type ())
 114 #define _gee_tree_set_node_free0(var) ((var == NULL) ? NULL : (var = (gee_tree_set_node_free (var), NULL)))
 115
 116 #define GEE_TREE_SET_NODE_TYPE_COLOR (gee_tree_set_node_color_get_type ())
 117
 118 #define GEE_TREE_SET_TYPE_ITERATOR (gee_tree_set_iterator_get_type ())
 119 #define GEE_TREE_SET_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TREE_SET_TYPE_ITERATOR, GeeTreeSetIterator))
 120 #define GEE_TREE_SET_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TREE_SET_TYPE_ITERATOR, GeeTreeSetIteratorClass))
 121 #define GEE_TREE_SET_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TREE_SET_TYPE_ITERATOR))
 122 #define GEE_TREE_SET_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TREE_SET_TYPE_ITERATOR))
 123 #define GEE_TREE_SET_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TREE_SET_TYPE_ITERATOR, GeeTreeSetIteratorClass))
 124
 125 typedef struct _GeeTreeSetIterator GeeTreeSetIterator;
 126 typedef struct _GeeTreeSetIteratorClass GeeTreeSetIteratorClass;
 127
 128 #define GEE_TREE_SET_TYPE_SUB_SET (gee_tree_set_sub_set_get_type ())
 129 #define GEE_TREE_SET_SUB_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TREE_SET_TYPE_SUB_SET, GeeTreeSetSubSet))
 130 #define GEE_TREE_SET_SUB_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TREE_SET_TYPE_SUB_SET, GeeTreeSetSubSetClass))
 131 #define GEE_TREE_SET_IS_SUB_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TREE_SET_TYPE_SUB_SET))
 132 #define GEE_TREE_SET_IS_SUB_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TREE_SET_TYPE_SUB_SET))
 133 #define GEE_TREE_SET_SUB_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TREE_SET_TYPE_SUB_SET, GeeTreeSetSubSetClass))
 134
 135 typedef struct _GeeTreeSetSubSet GeeTreeSetSubSet;
 136 typedef struct _GeeTreeSetSubSetClass GeeTreeSetSubSetClass;
 137 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 138 typedef struct _GeeTreeSetIteratorPrivate GeeTreeSetIteratorPrivate;
 139
 140 #define GEE_TREE_SET_TYPE_RANGE (gee_tree_set_range_get_type ())
 141 #define GEE_TREE_SET_RANGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TREE_SET_TYPE_RANGE, GeeTreeSetRange))
 142 #define GEE_TREE_SET_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TREE_SET_TYPE_RANGE, GeeTreeSetRangeClass))
 143 #define GEE_TREE_SET_IS_RANGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TREE_SET_TYPE_RANGE))
 144 #define GEE_TREE_SET_IS_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TREE_SET_TYPE_RANGE))
 145 #define GEE_TREE_SET_RANGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TREE_SET_TYPE_RANGE, GeeTreeSetRangeClass))
 146
 147 typedef struct _GeeTreeSetRange GeeTreeSetRange;
 148 typedef struct _GeeTreeSetRangeClass GeeTreeSetRangeClass;
 149 typedef struct _GeeTreeSetRangePrivate GeeTreeSetRangePrivate;
 150 #define _g_destroy_func0(var) (((var == NULL) || (g_destroy_func == NULL)) ? NULL : (var = (g_destroy_func (var), NULL)))
 151 typedef struct _GeeTreeSetParamSpecRange GeeTreeSetParamSpecRange;
 152 typedef struct _GeeTreeSetSubSetPrivate GeeTreeSetSubSetPrivate;
 153 #define _gee_tree_set_range_unref0(var) ((var == NULL) ? NULL : (var = (gee_tree_set_range_unref (var), NULL)))
 154
 155 #define GEE_TREE_SET_TYPE_SUB_ITERATOR (gee_tree_set_sub_iterator_get_type ())
 156 #define GEE_TREE_SET_SUB_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TREE_SET_TYPE_SUB_ITERATOR, GeeTreeSetSubIterator))
 157 #define GEE_TREE_SET_SUB_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TREE_SET_TYPE_SUB_ITERATOR, GeeTreeSetSubIteratorClass))
 158 #define GEE_TREE_SET_IS_SUB_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TREE_SET_TYPE_SUB_ITERATOR))
 159 #define GEE_TREE_SET_IS_SUB_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TREE_SET_TYPE_SUB_ITERATOR))
 160 #define GEE_TREE_SET_SUB_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TREE_SET_TYPE_SUB_ITERATOR, GeeTreeSetSubIteratorClass))
 161
 162 typedef struct _GeeTreeSetSubIterator GeeTreeSetSubIterator;
 163 typedef struct _GeeTreeSetSubIteratorClass GeeTreeSetSubIteratorClass;
 164 typedef struct _GeeTreeSetSubIteratorPrivate GeeTreeSetSubIteratorPrivate;
 165 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 166
 167 struct _GeeIteratorIface {
 168         GTypeInterface parent_iface;
 169         gboolean (*next) (GeeIterator* self);
 170         gboolean (*has_next) (GeeIterator* self);
 171         gboolean (*first) (GeeIterator* self);
 172         gpointer (*get) (GeeIterator* self);
 173         void (*remove) (GeeIterator* self);
 174 };
 175
 176 struct _GeeIterableIface {
 177         GTypeInterface parent_iface;
 178         GeeIterator* (*iterator) (GeeIterable* self);
 179         GType (*get_element_type) (GeeIterable* self);
 180 };
 181
 182 struct _GeeCollectionIface {
 183         GTypeInterface parent_iface;
 184         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 185         gboolean (*add) (GeeCollection* self, gconstpointer item);
 186         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 187         void (*clear) (GeeCollection* self);
 188         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 189         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 190         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 191         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 192         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 193         gint (*get_size) (GeeCollection* self);
 194         gboolean (*get_is_empty) (GeeCollection* self);
 195         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 196 };
 197
 198 struct _GeeAbstractCollection {
 199         GObject parent_instance;
 200         GeeAbstractCollectionPrivate * priv;
 201 };
 202
 203 struct _GeeAbstractCollectionClass {
 204         GObjectClass parent_class;
 205         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 206         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 207         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 208         void (*clear) (GeeAbstractCollection* self);
 209         gpointer* (*to_array) (GeeAbstractCollection* self, int* result_length1);
 210         gboolean (*add_all) (GeeAbstractCollection* self, GeeCollection* collection);
 211         gboolean (*contains_all) (GeeAbstractCollection* self, GeeCollection* collection);
 212         gboolean (*remove_all) (GeeAbstractCollection* self, GeeCollection* collection);
 213         gboolean (*retain_all) (GeeAbstractCollection* self, GeeCollection* collection);
 214         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 215         gint (*get_size) (GeeAbstractCollection* self);
 216         gboolean (*get_is_empty) (GeeAbstractCollection* self);
 217         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 218 };
 219
 220 struct _GeeSetIface {
 221         GTypeInterface parent_iface;
 222         GeeSet* (*get_read_only_view) (GeeSet* self);
 223 };
 224
 225 struct _GeeAbstractSet {
 226         GeeAbstractCollection parent_instance;
 227         GeeAbstractSetPrivate * priv;
 228 };
 229
 230 struct _GeeAbstractSetClass {
 231         GeeAbstractCollectionClass parent_class;
 232         GeeSet* (*get_read_only_view) (GeeAbstractSet* self);
 233 };
 234
 235 struct _GeeBidirIteratorIface {
 236         GTypeInterface parent_iface;
 237         gboolean (*previous) (GeeBidirIterator* self);
 238         gboolean (*has_previous) (GeeBidirIterator* self);
 239         gboolean (*last) (GeeBidirIterator* self);
 240 };
 241
 242 struct _GeeSortedSetIface {
 243         GTypeInterface parent_iface;
 244         gpointer (*first) (GeeSortedSet* self);
 245         gpointer (*last) (GeeSortedSet* self);
 246         GeeBidirIterator* (*bidir_iterator) (GeeSortedSet* self);
 247         GeeBidirIterator* (*iterator_at) (GeeSortedSet* self, gconstpointer element);
 248         gpointer (*lower) (GeeSortedSet* self, gconstpointer element);
 249         gpointer (*higher) (GeeSortedSet* self, gconstpointer element);
 250         gpointer (*floor) (GeeSortedSet* self, gconstpointer element);
 251         gpointer (*ceil) (GeeSortedSet* self, gconstpointer element);
 252         GeeSortedSet* (*head_set) (GeeSortedSet* self, gconstpointer before);
 253         GeeSortedSet* (*tail_set) (GeeSortedSet* self, gconstpointer after);
 254         GeeSortedSet* (*sub_set) (GeeSortedSet* self, gconstpointer from, gconstpointer to);
 255 };
 256
 257 struct _GeeTreeSet {
 258         GeeAbstractSet parent_instance;
 259         GeeTreeSetPrivate * priv;
 260 };
 261
 262 struct _GeeTreeSetClass {
 263         GeeAbstractSetClass parent_class;
 264 };
 265
 266 struct _GeeTreeSetPrivate {
 267         GType g_type;
 268         GBoxedCopyFunc g_dup_func;
 269         GDestroyNotify g_destroy_func;
 270         GCompareFunc _compare_func;
 271         gint _size;
 272         GeeTreeSetNode* root;
 273         GeeTreeSetNode* _first;
 274         GeeTreeSetNode* _last;
 275         gint stamp;
 276 };
 277
 278 typedef enum  {
 279         GEE_TREE_SET_RANGE_TYPE_HEAD,
 280         GEE_TREE_SET_RANGE_TYPE_TAIL,
 281         GEE_TREE_SET_RANGE_TYPE_EMPTY,
 282         GEE_TREE_SET_RANGE_TYPE_BOUNDED
 283 } GeeTreeSetRangeType;
 284
 285 typedef enum  {
 286         GEE_TREE_SET_NODE_COLOR_RED,
 287         GEE_TREE_SET_NODE_COLOR_BLACK
 288 } GeeTreeSetNodeColor;
 289
 290 struct _GeeTreeSetNode {
 291         gpointer key;
 292         GeeTreeSetNodeColor color;
 293         GeeTreeSetNode* left;
 294         GeeTreeSetNode* right;
 295         GeeTreeSetNode* prev;
 296         GeeTreeSetNode* next;
 297 };
 298
 299 struct _GeeTreeSetIterator {
 300         GObject parent_instance;
 301         GeeTreeSetIteratorPrivate * priv;
 302 };
 303
 304 struct _GeeTreeSetIteratorClass {
 305         GObjectClass parent_class;
 306 };
 307
 308 struct _GeeTreeSetIteratorPrivate {
 309         GType g_type;
 310         GBoxedCopyFunc g_dup_func;
 311         GDestroyNotify g_destroy_func;
 312         GeeTreeSet* _set;
 313         gint stamp;
 314         GeeTreeSetNode* current;
 315         GeeTreeSetNode* _next;
 316         GeeTreeSetNode* _prev;
 317         gboolean started;
 318 };
 319
 320 struct _GeeTreeSetRange {
 321         GTypeInstance parent_instance;
 322         volatile int ref_count;
 323         GeeTreeSetRangePrivate * priv;
 324 };
 325
 326 struct _GeeTreeSetRangeClass {
 327         GTypeClass parent_class;
 328         void (*finalize) (GeeTreeSetRange *self);
 329 };
 330
 331 struct _GeeTreeSetRangePrivate {
 332         GType g_type;
 333         GBoxedCopyFunc g_dup_func;
 334         GDestroyNotify g_destroy_func;
 335         GeeTreeSet* set;
 336         gpointer after;
 337         gpointer before;
 338         GeeTreeSetRangeType type;
 339 };
 340
 341 struct _GeeTreeSetParamSpecRange {
 342         GParamSpec parent_instance;
 343 };
 344
 345 struct _GeeTreeSetSubSet {
 346         GeeAbstractSet parent_instance;
 347         GeeTreeSetSubSetPrivate * priv;
 348 };
 349
 350 struct _GeeTreeSetSubSetClass {
 351         GeeAbstractSetClass parent_class;
 352 };
 353
 354 struct _GeeTreeSetSubSetPrivate {
 355         GType g_type;
 356         GBoxedCopyFunc g_dup_func;
 357         GDestroyNotify g_destroy_func;
 358         GeeTreeSet* set;
 359         GeeTreeSetRange* range;
 360 };
 361
 362 struct _GeeTreeSetSubIterator {
 363         GObject parent_instance;
 364         GeeTreeSetSubIteratorPrivate * priv;
 365 };
 366
 367 struct _GeeTreeSetSubIteratorClass {
 368         GObjectClass parent_class;
 369 };
 370
 371 struct _GeeTreeSetSubIteratorPrivate {
 372         GType g_type;
 373         GBoxedCopyFunc g_dup_func;
 374         GDestroyNotify g_destroy_func;
 375         GeeTreeSet* set;
 376         GeeTreeSetRange* range;
 377         GeeTreeSetIterator* iterator;
 378 };
 379
 380
 381 static gpointer gee_tree_set_parent_class = NULL;
 382 static gpointer gee_tree_set_iterator_parent_class = NULL;
 383 static GeeIteratorIface* gee_tree_set_iterator_gee_iterator_parent_iface = NULL;
 384 static GeeBidirIteratorIface* gee_tree_set_iterator_gee_bidir_iterator_parent_iface = NULL;
 385 static gpointer gee_tree_set_range_parent_class = NULL;
 386 static gpointer gee_tree_set_sub_set_parent_class = NULL;
 387 static GeeSortedSetIface* gee_tree_set_sub_set_gee_sorted_set_parent_iface = NULL;
 388 static gpointer gee_tree_set_sub_iterator_parent_class = NULL;
 389 static GeeIteratorIface* gee_tree_set_sub_iterator_gee_iterator_parent_iface = NULL;
 390 static GeeBidirIteratorIface* gee_tree_set_sub_iterator_gee_bidir_iterator_parent_iface = NULL;
 391 static GeeSortedSetIface* gee_tree_set_gee_sorted_set_parent_iface = NULL;
 392
 393 GType gee_iterator_get_type (void) G_GNUC_CONST;
 394 GType gee_iterable_get_type (void) G_GNUC_CONST;
 395 GType gee_collection_get_type (void) G_GNUC_CONST;
 396 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 397 GType gee_set_get_type (void) G_GNUC_CONST;
 398 GType gee_abstract_set_get_type (void) G_GNUC_CONST;
 399 GType gee_bidir_iterator_get_type (void) G_GNUC_CONST;
 400 GType gee_sorted_set_get_type (void) G_GNUC_CONST;
 401 GType gee_tree_set_get_type (void) G_GNUC_CONST;
 402 static void gee_tree_set_node_free (GeeTreeSetNode* self);
 403 #define GEE_TREE_SET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_TREE_SET, GeeTreeSetPrivate))
 404 enum  {
 405         GEE_TREE_SET_DUMMY_PROPERTY,
 406         GEE_TREE_SET_G_TYPE,
 407         GEE_TREE_SET_G_DUP_FUNC,
 408         GEE_TREE_SET_G_DESTROY_FUNC,
 409         GEE_TREE_SET_SIZE,
 410         GEE_TREE_SET_COMPARE_FUNC
 411 };
 412 static GType gee_tree_set_range_type_get_type (void) G_GNUC_UNUSED;
 413 GeeTreeSet* gee_tree_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareFunc compare_func);
 414 GeeTreeSet* gee_tree_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareFunc compare_func);
 415 GeeAbstractSet* gee_abstract_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 416 GCompareFunc gee_functions_get_compare_func_for (GType t);
 417 static void gee_tree_set_set_compare_func (GeeTreeSet* self, GCompareFunc value);
 418 static gboolean gee_tree_set_real_contains (GeeAbstractCollection* base, gconstpointer item);
 419 GCompareFunc gee_tree_set_get_compare_func (GeeTreeSet* self);
 420 GType gee_tree_set_node_color_get_type (void) G_GNUC_CONST;
 421 static inline void gee_tree_set_rotate_right (GeeTreeSet* self, GeeTreeSetNode** root);
 422 static inline void gee_tree_set_rotate_left (GeeTreeSet* self, GeeTreeSetNode** root);
 423 static inline gboolean gee_tree_set_is_red (GeeTreeSet* self, GeeTreeSetNode* n);
 424 static inline gboolean gee_tree_set_is_black (GeeTreeSet* self, GeeTreeSetNode* n);
 425 static inline void gee_tree_set_fix_up (GeeTreeSet* self, GeeTreeSetNode** node);
 426 static void gee_tree_set_node_flip (GeeTreeSetNode* self);
 427 static gboolean gee_tree_set_add_to_node (GeeTreeSet* self, GeeTreeSetNode** node, gpointer item, GeeTreeSetNode* prev, GeeTreeSetNode* next);
 428 static GeeTreeSetNode* gee_tree_set_node_new (gpointer node, GeeTreeSetNode* prev, GeeTreeSetNode* next);
 429 static GeeTreeSetNode* gee_tree_set_node_new (gpointer node, GeeTreeSetNode* prev, GeeTreeSetNode* next);
 430 static gboolean gee_tree_set_real_add (GeeAbstractCollection* base, gconstpointer item);
 431 static inline void gee_tree_set_move_red_left (GeeTreeSet* self, GeeTreeSetNode** root);
 432 static inline void gee_tree_set_move_red_right (GeeTreeSet* self, GeeTreeSetNode** root);
 433 static inline void gee_tree_set_fix_removal (GeeTreeSet* self, GeeTreeSetNode** node, gpointer* key);
 434 static void gee_tree_set_remove_minimal (GeeTreeSet* self, GeeTreeSetNode** node, gpointer* key);
 435 static gboolean gee_tree_set_remove_from_node (GeeTreeSet* self, GeeTreeSetNode** node, gconstpointer item, GeeTreeSetNode** prev, GeeTreeSetNode** next);
 436 static gboolean gee_tree_set_real_remove (GeeAbstractCollection* base, gconstpointer item);
 437 static inline void gee_tree_set_clear_subtree (GeeTreeSet* self, GeeTreeSetNode* node);
 438 static void gee_tree_set_real_clear (GeeAbstractCollection* base);
 439 static GeeIterator* gee_tree_set_real_iterator (GeeAbstractCollection* base);
 440 static GeeTreeSetIterator* gee_tree_set_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set);
 441 static GeeTreeSetIterator* gee_tree_set_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set);
 442 static GType gee_tree_set_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 443 static GeeBidirIterator* gee_tree_set_real_bidir_iterator (GeeSortedSet* base);
 444 static inline gpointer gee_tree_set_lift_null_get (GeeTreeSet* self, GeeTreeSetNode* node);
 445 static gpointer gee_tree_set_real_first (GeeSortedSet* base);
 446 static gpointer gee_tree_set_real_last (GeeSortedSet* base);
 447 static GeeSortedSet* gee_tree_set_real_head_set (GeeSortedSet* base, gconstpointer before);
 448 static GeeTreeSetSubSet* gee_tree_set_sub_set_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before);
 449 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before);
 450 static GType gee_tree_set_sub_set_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 451 static GeeSortedSet* gee_tree_set_real_tail_set (GeeSortedSet* base, gconstpointer after);
 452 static GeeTreeSetSubSet* gee_tree_set_sub_set_new_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after);
 453 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct_tail (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after);
 454 static GeeSortedSet* gee_tree_set_real_sub_set (GeeSortedSet* base, gconstpointer after, gconstpointer before);
 455 static GeeTreeSetSubSet* gee_tree_set_sub_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before);
 456 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before);
 457 static inline GeeTreeSetNode* gee_tree_set_find_node (GeeTreeSet* self, gconstpointer item);
 458 static GeeBidirIterator* gee_tree_set_real_iterator_at (GeeSortedSet* base, gconstpointer item);
 459 static GeeTreeSetIterator* gee_tree_set_iterator_new_pointing (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetNode* current);
 460 static GeeTreeSetIterator* gee_tree_set_iterator_construct_pointing (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetNode* current);
 461 static inline GeeTreeSetNode* gee_tree_set_find_nearest (GeeTreeSet* self, gconstpointer item);
 462 static inline GeeTreeSetNode* gee_tree_set_find_lower (GeeTreeSet* self, gconstpointer item);
 463 static inline GeeTreeSetNode* gee_tree_set_find_higher (GeeTreeSet* self, gconstpointer item);
 464 static inline GeeTreeSetNode* gee_tree_set_find_floor (GeeTreeSet* self, gconstpointer item);
 465 static inline GeeTreeSetNode* gee_tree_set_find_ceil (GeeTreeSet* self, gconstpointer item);
 466 static gpointer gee_tree_set_real_lower (GeeSortedSet* base, gconstpointer item);
 467 static gpointer gee_tree_set_real_higher (GeeSortedSet* base, gconstpointer item);
 468 static gpointer gee_tree_set_real_floor (GeeSortedSet* base, gconstpointer item);
 469 static gpointer gee_tree_set_real_ceil (GeeSortedSet* base, gconstpointer item);
 470 static inline gpointer gee_tree_set_min (GeeTreeSet* self, gconstpointer a, gconstpointer b);
 471 static inline gpointer gee_tree_set_max (GeeTreeSet* self, gconstpointer a, gconstpointer b);
 472 static void gee_tree_set_node_instance_init (GeeTreeSetNode * self);
 473 static GeeTreeSetNodeColor gee_tree_set_node_color_flip (GeeTreeSetNodeColor self);
 474 #define GEE_TREE_SET_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TREE_SET_TYPE_ITERATOR, GeeTreeSetIteratorPrivate))
 475 enum  {
 476         GEE_TREE_SET_ITERATOR_DUMMY_PROPERTY,
 477         GEE_TREE_SET_ITERATOR_G_TYPE,
 478         GEE_TREE_SET_ITERATOR_G_DUP_FUNC,
 479         GEE_TREE_SET_ITERATOR_G_DESTROY_FUNC
 480 };
 481 static gboolean gee_tree_set_iterator_real_next (GeeIterator* base);
 482 static gboolean gee_tree_set_iterator_real_has_next (GeeIterator* base);
 483 static gboolean gee_tree_set_iterator_real_first (GeeIterator* base);
 484 static gboolean gee_tree_set_iterator_real_previous (GeeBidirIterator* base);
 485 static gboolean gee_tree_set_iterator_real_has_previous (GeeBidirIterator* base);
 486 static gboolean gee_tree_set_iterator_real_last (GeeBidirIterator* base);
 487 static gpointer gee_tree_set_iterator_real_get (GeeIterator* base);
 488 static void gee_tree_set_iterator_real_remove (GeeIterator* base);
 489 static gboolean gee_tree_set_iterator_safe_next_get (GeeTreeSetIterator* self, gpointer* val);
 490 static gboolean gee_tree_set_iterator_safe_previous_get (GeeTreeSetIterator* self, gpointer* val);
 491 static void gee_tree_set_iterator_finalize (GObject* obj);
 492 static void _vala_gee_tree_set_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 493 static void _vala_gee_tree_set_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 494 static gpointer gee_tree_set_range_ref (gpointer instance);
 495 static void gee_tree_set_range_unref (gpointer instance);
 496 static GParamSpec* gee_tree_set_param_spec_range (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
 497 static void gee_tree_set_value_set_range (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 498 static void gee_tree_set_value_take_range (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 499 static gpointer gee_tree_set_value_get_range (const GValue* value) G_GNUC_UNUSED;
 500 static GType gee_tree_set_range_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 501 #define GEE_TREE_SET_RANGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TREE_SET_TYPE_RANGE, GeeTreeSetRangePrivate))
 502 enum  {
 503         GEE_TREE_SET_RANGE_DUMMY_PROPERTY
 504 };
 505 static GeeTreeSetRange* gee_tree_set_range_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before);
 506 static GeeTreeSetRange* gee_tree_set_range_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before);
 507 static GeeTreeSetRange* gee_tree_set_range_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before);
 508 static GeeTreeSetRange* gee_tree_set_range_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before);
 509 static GeeTreeSetRange* gee_tree_set_range_new_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after);
 510 static GeeTreeSetRange* gee_tree_set_range_construct_tail (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after);
 511 static GeeTreeSetRange* gee_tree_set_range_cut_head (GeeTreeSetRange* self, gconstpointer after);
 512 static GeeTreeSetRange* gee_tree_set_range_cut_tail (GeeTreeSetRange* self, gconstpointer before);
 513 static GeeTreeSetRange* gee_tree_set_range_cut (GeeTreeSetRange* self, gconstpointer after, gconstpointer before);
 514 static gboolean gee_tree_set_range_in_range (GeeTreeSetRange* self, gconstpointer item);
 515 static gint gee_tree_set_range_compare_range (GeeTreeSetRange* self, gconstpointer item);
 516 static gboolean gee_tree_set_range_empty_subset (GeeTreeSetRange* self);
 517 static GeeTreeSetNode* gee_tree_set_range_first (GeeTreeSetRange* self);
 518 static GeeTreeSetNode* gee_tree_set_range_last (GeeTreeSetRange* self);
 519 static void gee_tree_set_range_finalize (GeeTreeSetRange* obj);
 520 #define GEE_TREE_SET_SUB_SET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TREE_SET_TYPE_SUB_SET, GeeTreeSetSubSetPrivate))
 521 enum  {
 522         GEE_TREE_SET_SUB_SET_DUMMY_PROPERTY,
 523         GEE_TREE_SET_SUB_SET_G_TYPE,
 524         GEE_TREE_SET_SUB_SET_G_DUP_FUNC,
 525         GEE_TREE_SET_SUB_SET_G_DESTROY_FUNC,
 526         GEE_TREE_SET_SUB_SET_SIZE,
 527         GEE_TREE_SET_SUB_SET_IS_EMPTY
 528 };
 529 static GeeTreeSetSubSet* gee_tree_set_sub_set_new_from_range (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range);
 530 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct_from_range (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range);
 531 static gboolean gee_tree_set_sub_set_real_contains (GeeAbstractCollection* base, gconstpointer item);
 532 gboolean gee_abstract_collection_contains (GeeAbstractCollection* self, gconstpointer item);
 533 static gboolean gee_tree_set_sub_set_real_add (GeeAbstractCollection* base, gconstpointer item);
 534 gboolean gee_abstract_collection_add (GeeAbstractCollection* self, gconstpointer item);
 535 static gboolean gee_tree_set_sub_set_real_remove (GeeAbstractCollection* base, gconstpointer item);
 536 gboolean gee_abstract_collection_remove (GeeAbstractCollection* self, gconstpointer item);
 537 static void gee_tree_set_sub_set_real_clear (GeeAbstractCollection* base);
 538 GeeIterator* gee_abstract_collection_iterator (GeeAbstractCollection* self);
 539 gboolean gee_iterator_next (GeeIterator* self);
 540 void gee_iterator_remove (GeeIterator* self);
 541 static GeeIterator* gee_tree_set_sub_set_real_iterator (GeeAbstractCollection* base);
 542 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range);
 543 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range);
 544 static GType gee_tree_set_sub_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 545 static GeeBidirIterator* gee_tree_set_sub_set_real_bidir_iterator (GeeSortedSet* base);
 546 static gpointer gee_tree_set_sub_set_real_first (GeeSortedSet* base);
 547 static gpointer gee_tree_set_sub_set_real_last (GeeSortedSet* base);
 548 static GeeSortedSet* gee_tree_set_sub_set_real_head_set (GeeSortedSet* base, gconstpointer before);
 549 static GeeSortedSet* gee_tree_set_sub_set_real_tail_set (GeeSortedSet* base, gconstpointer after);
 550 static GeeSortedSet* gee_tree_set_sub_set_real_sub_set (GeeSortedSet* base, gconstpointer after, gconstpointer before);
 551 static GeeBidirIterator* gee_tree_set_sub_set_real_iterator_at (GeeSortedSet* base, gconstpointer item);
 552 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_new_pointing (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range, GeeTreeSetNode* node);
 553 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_construct_pointing (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range, GeeTreeSetNode* node);
 554 static gpointer gee_tree_set_sub_set_real_lower (GeeSortedSet* base, gconstpointer item);
 555 gpointer gee_sorted_set_last (GeeSortedSet* self);
 556 gpointer gee_sorted_set_lower (GeeSortedSet* self, gconstpointer element);
 557 static gpointer gee_tree_set_sub_set_real_higher (GeeSortedSet* base, gconstpointer item);
 558 gpointer gee_sorted_set_first (GeeSortedSet* self);
 559 gpointer gee_sorted_set_higher (GeeSortedSet* self, gconstpointer element);
 560 static gpointer gee_tree_set_sub_set_real_floor (GeeSortedSet* base, gconstpointer item);
 561 gpointer gee_sorted_set_floor (GeeSortedSet* self, gconstpointer element);
 562 static gpointer gee_tree_set_sub_set_real_ceil (GeeSortedSet* base, gconstpointer item);
 563 gpointer gee_sorted_set_ceil (GeeSortedSet* self, gconstpointer element);
 564 static void gee_tree_set_sub_set_finalize (GObject* obj);
 565 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 566 gboolean gee_abstract_collection_get_is_empty (GeeAbstractCollection* self);
 567 static void _vala_gee_tree_set_sub_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 568 static void _vala_gee_tree_set_sub_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 569 #define GEE_TREE_SET_SUB_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TREE_SET_TYPE_SUB_ITERATOR, GeeTreeSetSubIteratorPrivate))
 570 enum  {
 571         GEE_TREE_SET_SUB_ITERATOR_DUMMY_PROPERTY,
 572         GEE_TREE_SET_SUB_ITERATOR_G_TYPE,
 573         GEE_TREE_SET_SUB_ITERATOR_G_DUP_FUNC,
 574         GEE_TREE_SET_SUB_ITERATOR_G_DESTROY_FUNC
 575 };
 576 static gboolean gee_tree_set_sub_iterator_real_next (GeeIterator* base);
 577 gboolean gee_iterator_first (GeeIterator* self);
 578 static gboolean gee_tree_set_sub_iterator_real_has_next (GeeIterator* base);
 579 static gboolean gee_tree_set_sub_iterator_real_first (GeeIterator* base);
 580 static gboolean gee_tree_set_sub_iterator_real_previous (GeeBidirIterator* base);
 581 gboolean gee_bidir_iterator_previous (GeeBidirIterator* self);
 582 static gboolean gee_tree_set_sub_iterator_real_has_previous (GeeBidirIterator* base);
 583 static gboolean gee_tree_set_sub_iterator_real_last (GeeBidirIterator* base);
 584 static gpointer gee_tree_set_sub_iterator_real_get (GeeIterator* base);
 585 gpointer gee_iterator_get (GeeIterator* self);
 586 static void gee_tree_set_sub_iterator_real_remove (GeeIterator* base);
 587 static void gee_tree_set_sub_iterator_finalize (GObject* obj);
 588 static void _vala_gee_tree_set_sub_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 589 static void _vala_gee_tree_set_sub_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 590 static void gee_tree_set_finalize (GObject* obj);
 591 static void _vala_gee_tree_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 592 static void _vala_gee_tree_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 593
 594
 595 static GType gee_tree_set_range_type_get_type (void) {
 596         static volatile gsize gee_tree_set_range_type_type_id__volatile = 0;
 597         if (g_once_init_enter (&gee_tree_set_range_type_type_id__volatile)) {
 598                 static const GEnumValue values[] = {{GEE_TREE_SET_RANGE_TYPE_HEAD, "GEE_TREE_SET_RANGE_TYPE_HEAD", "head"}, {GEE_TREE_SET_RANGE_TYPE_TAIL, "GEE_TREE_SET_RANGE_TYPE_TAIL", "tail"}, {GEE_TREE_SET_RANGE_TYPE_EMPTY, "GEE_TREE_SET_RANGE_TYPE_EMPTY", "empty"}, {GEE_TREE_SET_RANGE_TYPE_BOUNDED, "GEE_TREE_SET_RANGE_TYPE_BOUNDED", "bounded"}, {0, NULL, NULL}};
 599                 GType gee_tree_set_range_type_type_id;
 600                 gee_tree_set_range_type_type_id = g_enum_register_static ("GeeTreeSetRangeType", values);
 601                 g_once_init_leave (&gee_tree_set_range_type_type_id__volatile, gee_tree_set_range_type_type_id);
 602         }
 603         return gee_tree_set_range_type_type_id__volatile;
 604 }
 605
 606
 607 /**
 608  * Constructs a new, empty tree set sorted according to the specified
 609  * comparator function.
 610  *
 611  * If not provided, the function parameter is requested to the
 612  * {@link Functions} function factory methods.
 613  *
 614  * @param compare_func an optional element comparator function
 615  */
 616 GeeTreeSet* gee_tree_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareFunc compare_func) {
 617         GeeTreeSet * self = NULL;
 618         GCompareFunc _tmp0_;
 619         GCompareFunc _tmp2_;
 620         self = (GeeTreeSet*) gee_abstract_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
 621         self->priv->g_type = g_type;
 622         self->priv->g_dup_func = g_dup_func;
 623         self->priv->g_destroy_func = g_destroy_func;
 624         _tmp0_ = compare_func;
 625         if (_tmp0_ == NULL) {
 626                 GCompareFunc _tmp1_ = NULL;
 627                 _tmp1_ = gee_functions_get_compare_func_for (g_type);
 628                 compare_func = _tmp1_;
 629         }
 630         _tmp2_ = compare_func;
 631         gee_tree_set_set_compare_func (self, _tmp2_);
 632         return self;
 633 }
 634
 635
 636 GeeTreeSet* gee_tree_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareFunc compare_func) {
 637         return gee_tree_set_construct (GEE_TYPE_TREE_SET, g_type, g_dup_func, g_destroy_func, compare_func);
 638 }
 639
 640
 641 /**
 642  * {@inheritDoc}
 643  */
 644 static gboolean gee_tree_set_real_contains (GeeAbstractCollection* base, gconstpointer item) {
 645         GeeTreeSet * self;
 646         gboolean result = FALSE;
 647         GeeTreeSetNode* _tmp0_;
 648         GeeTreeSetNode* cur;
 649         self = (GeeTreeSet*) base;
 650         _tmp0_ = self->priv->root;
 651         cur = _tmp0_;
 652         while (TRUE) {
 653                 GeeTreeSetNode* _tmp1_;
 654                 GCompareFunc _tmp2_;
 655                 GCompareFunc _tmp3_;
 656                 gconstpointer _tmp4_;
 657                 GeeTreeSetNode* _tmp5_;
 658                 gconstpointer _tmp6_;
 659                 gint _tmp7_ = 0;
 660                 gint res;
 661                 gint _tmp8_;
 662                 _tmp1_ = cur;
 663                 if (!(_tmp1_ != NULL)) {
 664                         break;
 665                 }
 666                 _tmp2_ = gee_tree_set_get_compare_func (self);
 667                 _tmp3_ = _tmp2_;
 668                 _tmp4_ = item;
 669                 _tmp5_ = cur;
 670                 _tmp6_ = _tmp5_->key;
 671                 _tmp7_ = _tmp3_ (_tmp4_, _tmp6_);
 672                 res = _tmp7_;
 673                 _tmp8_ = res;
 674                 if (_tmp8_ == 0) {
 675                         result = TRUE;
 676                         return result;
 677                 } else {
 678                         gint _tmp9_;
 679                         _tmp9_ = res;
 680                         if (_tmp9_ < 0) {
 681                                 GeeTreeSetNode* _tmp10_;
 682                                 GeeTreeSetNode* _tmp11_;
 683                                 _tmp10_ = cur;
 684                                 _tmp11_ = _tmp10_->left;
 685                                 cur = _tmp11_;
 686                         } else {
 687                                 GeeTreeSetNode* _tmp12_;
 688                                 GeeTreeSetNode* _tmp13_;
 689                                 _tmp12_ = cur;
 690                                 _tmp13_ = _tmp12_->right;
 691                                 cur = _tmp13_;
 692                         }
 693                 }
 694         }
 695         result = FALSE;
 696         return result;
 697 }
 698
 699
 700 static inline void gee_tree_set_rotate_right (GeeTreeSet* self, GeeTreeSetNode** root) {
 701         GeeTreeSetNode* _tmp0_;
 702         GeeTreeSetNode* _tmp1_;
 703         GeeTreeSetNode* pivot;
 704         GeeTreeSetNode* _tmp2_;
 705         GeeTreeSetNode* _tmp3_;
 706         GeeTreeSetNodeColor _tmp4_;
 707         GeeTreeSetNode* _tmp5_;
 708         GeeTreeSetNode* _tmp6_;
 709         GeeTreeSetNode* _tmp7_;
 710         GeeTreeSetNode* _tmp8_;
 711         GeeTreeSetNode* _tmp9_;
 712         GeeTreeSetNode* _tmp10_;
 713         GeeTreeSetNode* _tmp11_;
 714         g_return_if_fail (self != NULL);
 715         g_return_if_fail (*root != NULL);
 716         _tmp0_ = *root;
 717         _tmp1_ = _tmp0_->left;
 718         _tmp0_->left = NULL;
 719         pivot = _tmp1_;
 720         _tmp2_ = pivot;
 721         _tmp3_ = *root;
 722         _tmp4_ = _tmp3_->color;
 723         _tmp2_->color = _tmp4_;
 724         _tmp5_ = *root;
 725         _tmp5_->color = GEE_TREE_SET_NODE_COLOR_RED;
 726         _tmp6_ = *root;
 727         _tmp7_ = pivot;
 728         _tmp8_ = _tmp7_->right;
 729         _tmp7_->right = NULL;
 730         _gee_tree_set_node_free0 (_tmp6_->left);
 731         _tmp6_->left = _tmp8_;
 732         _tmp9_ = pivot;
 733         _tmp10_ = *root;
 734         *root = NULL;
 735         _gee_tree_set_node_free0 (_tmp9_->right);
 736         _tmp9_->right = _tmp10_;
 737         _tmp11_ = pivot;
 738         pivot = NULL;
 739         _gee_tree_set_node_free0 (*root);
 740         *root = _tmp11_;
 741         _gee_tree_set_node_free0 (pivot);
 742 }
 743
 744
 745 static inline void gee_tree_set_rotate_left (GeeTreeSet* self, GeeTreeSetNode** root) {
 746         GeeTreeSetNode* _tmp0_;
 747         GeeTreeSetNode* _tmp1_;
 748         GeeTreeSetNode* pivot;
 749         GeeTreeSetNode* _tmp2_;
 750         GeeTreeSetNode* _tmp3_;
 751         GeeTreeSetNodeColor _tmp4_;
 752         GeeTreeSetNode* _tmp5_;
 753         GeeTreeSetNode* _tmp6_;
 754         GeeTreeSetNode* _tmp7_;
 755         GeeTreeSetNode* _tmp8_;
 756         GeeTreeSetNode* _tmp9_;
 757         GeeTreeSetNode* _tmp10_;
 758         GeeTreeSetNode* _tmp11_;
 759         g_return_if_fail (self != NULL);
 760         g_return_if_fail (*root != NULL);
 761         _tmp0_ = *root;
 762         _tmp1_ = _tmp0_->right;
 763         _tmp0_->right = NULL;
 764         pivot = _tmp1_;
 765         _tmp2_ = pivot;
 766         _tmp3_ = *root;
 767         _tmp4_ = _tmp3_->color;
 768         _tmp2_->color = _tmp4_;
 769         _tmp5_ = *root;
 770         _tmp5_->color = GEE_TREE_SET_NODE_COLOR_RED;
 771         _tmp6_ = *root;
 772         _tmp7_ = pivot;
 773         _tmp8_ = _tmp7_->left;
 774         _tmp7_->left = NULL;
 775         _gee_tree_set_node_free0 (_tmp6_->right);
 776         _tmp6_->right = _tmp8_;
 777         _tmp9_ = pivot;
 778         _tmp10_ = *root;
 779         *root = NULL;
 780         _gee_tree_set_node_free0 (_tmp9_->left);
 781         _tmp9_->left = _tmp10_;
 782         _tmp11_ = pivot;
 783         pivot = NULL;
 784         _gee_tree_set_node_free0 (*root);
 785         *root = _tmp11_;
 786         _gee_tree_set_node_free0 (pivot);
 787 }
 788
 789
 790 static inline gboolean gee_tree_set_is_red (GeeTreeSet* self, GeeTreeSetNode* n) {
 791         gboolean result = FALSE;
 792         gboolean _tmp0_ = FALSE;
 793         GeeTreeSetNode* _tmp1_;
 794         gboolean _tmp4_;
 795         g_return_val_if_fail (self != NULL, FALSE);
 796         _tmp1_ = n;
 797         if (_tmp1_ != NULL) {
 798                 GeeTreeSetNode* _tmp2_;
 799                 GeeTreeSetNodeColor _tmp3_;
 800                 _tmp2_ = n;
 801                 _tmp3_ = _tmp2_->color;
 802                 _tmp0_ = _tmp3_ == GEE_TREE_SET_NODE_COLOR_RED;
 803         } else {
 804                 _tmp0_ = FALSE;
 805         }
 806         _tmp4_ = _tmp0_;
 807         result = _tmp4_;
 808         return result;
 809 }
 810
 811
 812 static inline gboolean gee_tree_set_is_black (GeeTreeSet* self, GeeTreeSetNode* n) {
 813         gboolean result = FALSE;
 814         gboolean _tmp0_ = FALSE;
 815         GeeTreeSetNode* _tmp1_;
 816         gboolean _tmp4_;
 817         g_return_val_if_fail (self != NULL, FALSE);
 818         _tmp1_ = n;
 819         if (_tmp1_ == NULL) {
 820                 _tmp0_ = TRUE;
 821         } else {
 822                 GeeTreeSetNode* _tmp2_;
 823                 GeeTreeSetNodeColor _tmp3_;
 824                 _tmp2_ = n;
 825                 _tmp3_ = _tmp2_->color;
 826                 _tmp0_ = _tmp3_ == GEE_TREE_SET_NODE_COLOR_BLACK;
 827         }
 828         _tmp4_ = _tmp0_;
 829         result = _tmp4_;
 830         return result;
 831 }
 832
 833
 834 static inline void gee_tree_set_fix_up (GeeTreeSet* self, GeeTreeSetNode** node) {
 835         gboolean _tmp0_ = FALSE;
 836         GeeTreeSetNode* _tmp1_;
 837         GeeTreeSetNode* _tmp2_;
 838         gboolean _tmp3_ = FALSE;
 839         gboolean _tmp7_;
 840         gboolean _tmp8_ = FALSE;
 841         GeeTreeSetNode* _tmp9_;
 842         GeeTreeSetNode* _tmp10_;
 843         gboolean _tmp11_ = FALSE;
 844         gboolean _tmp16_;
 845         gboolean _tmp17_ = FALSE;
 846         GeeTreeSetNode* _tmp18_;
 847         GeeTreeSetNode* _tmp19_;
 848         gboolean _tmp20_ = FALSE;
 849         gboolean _tmp24_;
 850         g_return_if_fail (self != NULL);
 851         g_return_if_fail (*node != NULL);
 852         _tmp1_ = *node;
 853         _tmp2_ = _tmp1_->left;
 854         _tmp3_ = gee_tree_set_is_black (self, _tmp2_);
 855         if (_tmp3_) {
 856                 GeeTreeSetNode* _tmp4_;
 857                 GeeTreeSetNode* _tmp5_;
 858                 gboolean _tmp6_ = FALSE;
 859                 _tmp4_ = *node;
 860                 _tmp5_ = _tmp4_->right;
 861                 _tmp6_ = gee_tree_set_is_red (self, _tmp5_);
 862                 _tmp0_ = _tmp6_;
 863         } else {
 864                 _tmp0_ = FALSE;
 865         }
 866         _tmp7_ = _tmp0_;
 867         if (_tmp7_) {
 868                 gee_tree_set_rotate_left (self, node);
 869         }
 870         _tmp9_ = *node;
 871         _tmp10_ = _tmp9_->left;
 872         _tmp11_ = gee_tree_set_is_red (self, _tmp10_);
 873         if (_tmp11_) {
 874                 GeeTreeSetNode* _tmp12_;
 875                 GeeTreeSetNode* _tmp13_;
 876                 GeeTreeSetNode* _tmp14_;
 877                 gboolean _tmp15_ = FALSE;
 878                 _tmp12_ = *node;
 879                 _tmp13_ = _tmp12_->left;
 880                 _tmp14_ = _tmp13_->left;
 881                 _tmp15_ = gee_tree_set_is_red (self, _tmp14_);
 882                 _tmp8_ = _tmp15_;
 883         } else {
 884                 _tmp8_ = FALSE;
 885         }
 886         _tmp16_ = _tmp8_;
 887         if (_tmp16_) {
 888                 gee_tree_set_rotate_right (self, node);
 889         }
 890         _tmp18_ = *node;
 891         _tmp19_ = _tmp18_->left;
 892         _tmp20_ = gee_tree_set_is_red (self, _tmp19_);
 893         if (_tmp20_) {
 894                 GeeTreeSetNode* _tmp21_;
 895                 GeeTreeSetNode* _tmp22_;
 896                 gboolean _tmp23_ = FALSE;
 897                 _tmp21_ = *node;
 898                 _tmp22_ = _tmp21_->right;
 899                 _tmp23_ = gee_tree_set_is_red (self, _tmp22_);
 900                 _tmp17_ = _tmp23_;
 901         } else {
 902                 _tmp17_ = FALSE;
 903         }
 904         _tmp24_ = _tmp17_;
 905         if (_tmp24_) {
 906                 GeeTreeSetNode* _tmp25_;
 907                 _tmp25_ = *node;
 908                 gee_tree_set_node_flip (_tmp25_);
 909         }
 910 }
 911
 912
 913 static gboolean gee_tree_set_add_to_node (GeeTreeSet* self, GeeTreeSetNode** node, gpointer item, GeeTreeSetNode* prev, GeeTreeSetNode* next) {
 914         gboolean result = FALSE;
 915         GeeTreeSetNode* _tmp0_;
 916         GCompareFunc _tmp10_;
 917         GCompareFunc _tmp11_;
 918         gconstpointer _tmp12_;
 919         GeeTreeSetNode* _tmp13_;
 920         gconstpointer _tmp14_;
 921         gint _tmp15_ = 0;
 922         gint cmp;
 923         gint _tmp16_;
 924         g_return_val_if_fail (self != NULL, FALSE);
 925         _tmp0_ = *node;
 926         if (_tmp0_ == NULL) {
 927                 gpointer _tmp1_;
 928                 GeeTreeSetNode* _tmp2_;
 929                 GeeTreeSetNode* _tmp3_;
 930                 GeeTreeSetNode* _tmp4_;
 931                 GeeTreeSetNode* _tmp5_;
 932                 GeeTreeSetNode* _tmp7_;
 933                 gint _tmp9_;
 934                 _tmp1_ = item;
 935                 item = NULL;
 936                 _tmp2_ = prev;
 937                 _tmp3_ = next;
 938                 _tmp4_ = gee_tree_set_node_new (_tmp1_, _tmp2_, _tmp3_);
 939                 _gee_tree_set_node_free0 (*node);
 940                 *node = _tmp4_;
 941                 _tmp5_ = prev;
 942                 if (_tmp5_ == NULL) {
 943                         GeeTreeSetNode* _tmp6_;
 944                         _tmp6_ = *node;
 945                         self->priv->_first = _tmp6_;
 946                 }
 947                 _tmp7_ = next;
 948                 if (_tmp7_ == NULL) {
 949                         GeeTreeSetNode* _tmp8_;
 950                         _tmp8_ = *node;
 951                         self->priv->_last = _tmp8_;
 952                 }
 953                 _tmp9_ = self->priv->_size;
 954                 self->priv->_size = _tmp9_ + 1;
 955                 result = TRUE;
 956                 ((item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (item = (self->priv->g_destroy_func (item), NULL));
 957                 return result;
 958         }
 959         _tmp10_ = gee_tree_set_get_compare_func (self);
 960         _tmp11_ = _tmp10_;
 961         _tmp12_ = item;
 962         _tmp13_ = *node;
 963         _tmp14_ = _tmp13_->key;
 964         _tmp15_ = _tmp11_ (_tmp12_, _tmp14_);
 965         cmp = _tmp15_;
 966         _tmp16_ = cmp;
 967         if (_tmp16_ == 0) {
 968                 gee_tree_set_fix_up (self, node);
 969                 result = FALSE;
 970                 ((item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (item = (self->priv->g_destroy_func (item), NULL));
 971                 return result;
 972         } else {
 973                 gint _tmp17_;
 974                 _tmp17_ = cmp;
 975                 if (_tmp17_ < 0) {
 976                         GeeTreeSetNode* _tmp18_;
 977                         gconstpointer _tmp19_;
 978                         gpointer _tmp20_;
 979                         GeeTreeSetNode* _tmp21_;
 980                         GeeTreeSetNode* _tmp22_;
 981                         GeeTreeSetNode* _tmp23_;
 982                         gboolean _tmp24_ = FALSE;
 983                         gboolean r;
 984                         _tmp18_ = *node;
 985                         _tmp19_ = item;
 986                         _tmp20_ = ((_tmp19_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp19_) : ((gpointer) _tmp19_);
 987                         _tmp21_ = *node;
 988                         _tmp22_ = _tmp21_->prev;
 989                         _tmp23_ = *node;
 990                         _tmp24_ = gee_tree_set_add_to_node (self, &_tmp18_->left, _tmp20_, _tmp22_, _tmp23_);
 991                         r = _tmp24_;
 992                         gee_tree_set_fix_up (self, node);
 993                         result = r;
 994                         ((item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (item = (self->priv->g_destroy_func (item), NULL));
 995                         return result;
 996                 } else {
 997                         GeeTreeSetNode* _tmp25_;
 998                         gconstpointer _tmp26_;
 999                         gpointer _tmp27_;
1000                         GeeTreeSetNode* _tmp28_;
1001                         GeeTreeSetNode* _tmp29_;
1002                         GeeTreeSetNode* _tmp30_;
1003                         gboolean _tmp31_ = FALSE;
1004                         gboolean r;
1005                         _tmp25_ = *node;
1006                         _tmp26_ = item;
1007                         _tmp27_ = ((_tmp26_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp26_) : ((gpointer) _tmp26_);
1008                         _tmp28_ = *node;
1009                         _tmp29_ = *node;
1010                         _tmp30_ = _tmp29_->next;
1011                         _tmp31_ = gee_tree_set_add_to_node (self, &_tmp25_->right, _tmp27_, _tmp28_, _tmp30_);
1012                         r = _tmp31_;
1013                         gee_tree_set_fix_up (self, node);
1014                         result = r;
1015                         ((item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (item = (self->priv->g_destroy_func (item), NULL));
1016                         return result;
1017                 }
1018         }
1019         ((item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (item = (self->priv->g_destroy_func (item), NULL));
1020 }
1021
1022
1023 /**
1024  * {@inheritDoc}
1025  *
1026  * If the element already exists in the set it will not be added twice.
1027  */
1028 static gboolean gee_tree_set_real_add (GeeAbstractCollection* base, gconstpointer item) {
1029         GeeTreeSet * self;
1030         gboolean result = FALSE;
1031         gconstpointer _tmp0_;
1032         gpointer _tmp1_;
1033         gboolean _tmp2_ = FALSE;
1034         gboolean r;
1035         GeeTreeSetNode* _tmp3_;
1036         gint _tmp4_;
1037         self = (GeeTreeSet*) base;
1038         _tmp0_ = item;
1039         _tmp1_ = ((_tmp0_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
1040         _tmp2_ = gee_tree_set_add_to_node (self, &self->priv->root, _tmp1_, NULL, NULL);
1041         r = _tmp2_;
1042         _tmp3_ = self->priv->root;
1043         _tmp3_->color = GEE_TREE_SET_NODE_COLOR_BLACK;
1044         _tmp4_ = self->priv->stamp;
1045         self->priv->stamp = _tmp4_ + 1;
1046         result = r;
1047         return result;
1048 }
1049
1050
1051 static inline void gee_tree_set_move_red_left (GeeTreeSet* self, GeeTreeSetNode** root) {
1052         GeeTreeSetNode* _tmp0_;
1053         GeeTreeSetNode* _tmp1_;
1054         GeeTreeSetNode* _tmp2_;
1055         GeeTreeSetNode* _tmp3_;
1056         gboolean _tmp4_ = FALSE;
1057         g_return_if_fail (self != NULL);
1058         g_return_if_fail (*root != NULL);
1059         _tmp0_ = *root;
1060         gee_tree_set_node_flip (_tmp0_);
1061         _tmp1_ = *root;
1062         _tmp2_ = _tmp1_->right;
1063         _tmp3_ = _tmp2_->left;
1064         _tmp4_ = gee_tree_set_is_red (self, _tmp3_);
1065         if (_tmp4_) {
1066                 GeeTreeSetNode* _tmp5_;
1067                 GeeTreeSetNode* _tmp6_;
1068                 _tmp5_ = *root;
1069                 gee_tree_set_rotate_right (self, &_tmp5_->right);
1070                 gee_tree_set_rotate_left (self, root);
1071                 _tmp6_ = *root;
1072                 gee_tree_set_node_flip (_tmp6_);
1073         }
1074 }
1075
1076
1077 static inline void gee_tree_set_move_red_right (GeeTreeSet* self, GeeTreeSetNode** root) {
1078         GeeTreeSetNode* _tmp0_;
1079         GeeTreeSetNode* _tmp1_;
1080         GeeTreeSetNode* _tmp2_;
1081         GeeTreeSetNode* _tmp3_;
1082         gboolean _tmp4_ = FALSE;
1083         g_return_if_fail (self != NULL);
1084         g_return_if_fail (*root != NULL);
1085         _tmp0_ = *root;
1086         gee_tree_set_node_flip (_tmp0_);
1087         _tmp1_ = *root;
1088         _tmp2_ = _tmp1_->left;
1089         _tmp3_ = _tmp2_->left;
1090         _tmp4_ = gee_tree_set_is_red (self, _tmp3_);
1091         if (_tmp4_) {
1092                 GeeTreeSetNode* _tmp5_;
1093                 gee_tree_set_rotate_right (self, root);
1094                 _tmp5_ = *root;
1095                 gee_tree_set_node_flip (_tmp5_);
1096         }
1097 }
1098
1099
1100 static inline void gee_tree_set_fix_removal (GeeTreeSet* self, GeeTreeSetNode** node, gpointer* key) {
1101         gpointer _vala_key = NULL;
1102         GeeTreeSetNode* _tmp0_;
1103         GeeTreeSetNode* n;
1104         GeeTreeSetNode* _tmp4_;
1105         GeeTreeSetNode* _tmp5_;
1106         GeeTreeSetNode* _tmp12_;
1107         GeeTreeSetNode* _tmp13_;
1108         gint _tmp20_;
1109         g_return_if_fail (self != NULL);
1110         g_return_if_fail (*node != NULL);
1111         _tmp0_ = *node;
1112         *node = NULL;
1113         n = _tmp0_;
1114         if ((&_vala_key) != NULL) {
1115                 GeeTreeSetNode* _tmp1_;
1116                 gpointer _tmp2_;
1117                 _tmp1_ = n;
1118                 _tmp2_ = _tmp1_->key;
1119                 _tmp1_->key = NULL;
1120                 ((_vala_key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_key = (self->priv->g_destroy_func (_vala_key), NULL));
1121                 _vala_key = _tmp2_;
1122         } else {
1123                 GeeTreeSetNode* _tmp3_;
1124                 _tmp3_ = n;
1125                 ((_tmp3_->key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp3_->key = (self->priv->g_destroy_func (_tmp3_->key), NULL));
1126                 _tmp3_->key = NULL;
1127         }
1128         _tmp4_ = n;
1129         _tmp5_ = _tmp4_->prev;
1130         if (_tmp5_ != NULL) {
1131                 GeeTreeSetNode* _tmp6_;
1132                 GeeTreeSetNode* _tmp7_;
1133                 GeeTreeSetNode* _tmp8_;
1134                 GeeTreeSetNode* _tmp9_;
1135                 _tmp6_ = n;
1136                 _tmp7_ = _tmp6_->prev;
1137                 _tmp8_ = n;
1138                 _tmp9_ = _tmp8_->next;
1139                 _tmp7_->next = _tmp9_;
1140         } else {
1141                 GeeTreeSetNode* _tmp10_;
1142                 GeeTreeSetNode* _tmp11_;
1143                 _tmp10_ = n;
1144                 _tmp11_ = _tmp10_->next;
1145                 self->priv->_first = _tmp11_;
1146         }
1147         _tmp12_ = n;
1148         _tmp13_ = _tmp12_->next;
1149         if (_tmp13_ != NULL) {
1150                 GeeTreeSetNode* _tmp14_;
1151                 GeeTreeSetNode* _tmp15_;
1152                 GeeTreeSetNode* _tmp16_;
1153                 GeeTreeSetNode* _tmp17_;
1154                 _tmp14_ = n;
1155                 _tmp15_ = _tmp14_->next;
1156                 _tmp16_ = n;
1157                 _tmp17_ = _tmp16_->prev;
1158                 _tmp15_->prev = _tmp17_;
1159         } else {
1160                 GeeTreeSetNode* _tmp18_;
1161                 GeeTreeSetNode* _tmp19_;
1162                 _tmp18_ = n;
1163                 _tmp19_ = _tmp18_->prev;
1164                 self->priv->_last = _tmp19_;
1165         }
1166         _gee_tree_set_node_free0 (*node);
1167         *node = NULL;
1168         _tmp20_ = self->priv->_size;
1169         self->priv->_size = _tmp20_ - 1;
1170         _gee_tree_set_node_free0 (n);
1171         if (key) {
1172                 *key = _vala_key;
1173         } else {
1174                 ((_vala_key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_key = (self->priv->g_destroy_func (_vala_key), NULL));
1175         }
1176 }
1177
1178
1179 static void gee_tree_set_remove_minimal (GeeTreeSet* self, GeeTreeSetNode** node, gpointer* key) {
1180         gpointer _vala_key = NULL;
1181         GeeTreeSetNode* _tmp0_;
1182         GeeTreeSetNode* _tmp1_;
1183         gboolean _tmp3_ = FALSE;
1184         GeeTreeSetNode* _tmp4_;
1185         GeeTreeSetNode* _tmp5_;
1186         gboolean _tmp6_ = FALSE;
1187         gboolean _tmp11_;
1188         GeeTreeSetNode* _tmp12_;
1189         gpointer _tmp13_ = NULL;
1190         g_return_if_fail (self != NULL);
1191         g_return_if_fail (*node != NULL);
1192         _tmp0_ = *node;
1193         _tmp1_ = _tmp0_->left;
1194         if (_tmp1_ == NULL) {
1195                 gpointer _tmp2_ = NULL;
1196                 gee_tree_set_fix_removal (self, node, &_tmp2_);
1197                 ((_vala_key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_key = (self->priv->g_destroy_func (_vala_key), NULL));
1198                 _vala_key = _tmp2_;
1199                 if (key) {
1200                         *key = _vala_key;
1201                 } else {
1202                         ((_vala_key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_key = (self->priv->g_destroy_func (_vala_key), NULL));
1203                 }
1204                 return;
1205         }
1206         _tmp4_ = *node;
1207         _tmp5_ = _tmp4_->left;
1208         _tmp6_ = gee_tree_set_is_black (self, _tmp5_);
1209         if (_tmp6_) {
1210                 GeeTreeSetNode* _tmp7_;
1211                 GeeTreeSetNode* _tmp8_;
1212                 GeeTreeSetNode* _tmp9_;
1213                 gboolean _tmp10_ = FALSE;
1214                 _tmp7_ = *node;
1215                 _tmp8_ = _tmp7_->left;
1216                 _tmp9_ = _tmp8_->left;
1217                 _tmp10_ = gee_tree_set_is_black (self, _tmp9_);
1218                 _tmp3_ = _tmp10_;
1219         } else {
1220                 _tmp3_ = FALSE;
1221         }
1222         _tmp11_ = _tmp3_;
1223         if (_tmp11_) {
1224                 gee_tree_set_move_red_left (self, node);
1225         }
1226         _tmp12_ = *node;
1227         gee_tree_set_remove_minimal (self, &_tmp12_->left, &_tmp13_);
1228         ((_vala_key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_key = (self->priv->g_destroy_func (_vala_key), NULL));
1229         _vala_key = _tmp13_;
1230         gee_tree_set_fix_up (self, node);
1231         if (key) {
1232                 *key = _vala_key;
1233         } else {
1234                 ((_vala_key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_key = (self->priv->g_destroy_func (_vala_key), NULL));
1235         }
1236 }
1237
1238
1239 static gboolean gee_tree_set_remove_from_node (GeeTreeSet* self, GeeTreeSetNode** node, gconstpointer item, GeeTreeSetNode** prev, GeeTreeSetNode** next) {
1240         GeeTreeSetNode* _vala_prev = NULL;
1241         GeeTreeSetNode* _vala_next = NULL;
1242         gboolean result = FALSE;
1243         GeeTreeSetNode* _tmp0_;
1244         g_return_val_if_fail (self != NULL, FALSE);
1245         _tmp0_ = *node;
1246         if (_tmp0_ == NULL) {
1247                 result = FALSE;
1248                 if (prev) {
1249                         *prev = _vala_prev;
1250                 }
1251                 if (next) {
1252                         *next = _vala_next;
1253                 }
1254                 return result;
1255         } else {
1256                 GCompareFunc _tmp1_;
1257                 GCompareFunc _tmp2_;
1258                 gconstpointer _tmp3_;
1259                 GeeTreeSetNode* _tmp4_;
1260                 gconstpointer _tmp5_;
1261                 gint _tmp6_ = 0;
1262                 _tmp1_ = gee_tree_set_get_compare_func (self);
1263                 _tmp2_ = _tmp1_;
1264                 _tmp3_ = item;
1265                 _tmp4_ = *node;
1266                 _tmp5_ = _tmp4_->key;
1267                 _tmp6_ = _tmp2_ (_tmp3_, _tmp5_);
1268                 if (_tmp6_ < 0) {
1269                         GeeTreeSetNode* _tmp7_;
1270                         GeeTreeSetNode* _tmp8_;
1271                         GeeTreeSetNode* left;
1272                         GeeTreeSetNode* _tmp9_;
1273                         gboolean _tmp10_ = FALSE;
1274                         GeeTreeSetNode* _tmp11_;
1275                         gboolean _tmp12_ = FALSE;
1276                         gboolean _tmp16_;
1277                         GeeTreeSetNode* _tmp17_;
1278                         gconstpointer _tmp18_;
1279                         GeeTreeSetNode* _tmp19_ = NULL;
1280                         GeeTreeSetNode* _tmp20_ = NULL;
1281                         gboolean _tmp21_ = FALSE;
1282                         gboolean r;
1283                         _tmp7_ = *node;
1284                         _tmp8_ = _tmp7_->left;
1285                         left = _tmp8_;
1286                         _tmp9_ = left;
1287                         if (_tmp9_ == NULL) {
1288                                 result = FALSE;
1289                                 if (prev) {
1290                                         *prev = _vala_prev;
1291                                 }
1292                                 if (next) {
1293                                         *next = _vala_next;
1294                                 }
1295                                 return result;
1296                         }
1297                         _tmp11_ = left;
1298                         _tmp12_ = gee_tree_set_is_black (self, _tmp11_);
1299                         if (_tmp12_) {
1300                                 GeeTreeSetNode* _tmp13_;
1301                                 GeeTreeSetNode* _tmp14_;
1302                                 gboolean _tmp15_ = FALSE;
1303                                 _tmp13_ = left;
1304                                 _tmp14_ = _tmp13_->left;
1305                                 _tmp15_ = gee_tree_set_is_black (self, _tmp14_);
1306                                 _tmp10_ = _tmp15_;
1307                         } else {
1308                                 _tmp10_ = FALSE;
1309                         }
1310                         _tmp16_ = _tmp10_;
1311                         if (_tmp16_) {
1312                                 gee_tree_set_move_red_left (self, node);
1313                         }
1314                         _tmp17_ = *node;
1315                         _tmp18_ = item;
1316                         _tmp21_ = gee_tree_set_remove_from_node (self, &_tmp17_->left, _tmp18_, &_tmp19_, &_tmp20_);
1317                         _vala_prev = _tmp19_;
1318                         _vala_next = _tmp20_;
1319                         r = _tmp21_;
1320                         gee_tree_set_fix_up (self, node);
1321                         result = r;
1322                         if (prev) {
1323                                 *prev = _vala_prev;
1324                         }
1325                         if (next) {
1326                                 *next = _vala_next;
1327                         }
1328                         return result;
1329                 } else {
1330                         GeeTreeSetNode* _tmp22_;
1331                         GeeTreeSetNode* _tmp23_;
1332                         gboolean _tmp24_ = FALSE;
1333                         GeeTreeSetNode* _tmp25_;
1334                         GeeTreeSetNode* _tmp26_;
1335                         GeeTreeSetNode* r;
1336                         gboolean _tmp27_ = FALSE;
1337                         GCompareFunc _tmp28_;
1338                         GCompareFunc _tmp29_;
1339                         gconstpointer _tmp30_;
1340                         GeeTreeSetNode* _tmp31_;
1341                         gconstpointer _tmp32_;
1342                         gint _tmp33_ = 0;
1343                         gboolean _tmp35_;
1344                         gboolean _tmp40_ = FALSE;
1345                         gboolean _tmp41_ = FALSE;
1346                         GeeTreeSetNode* _tmp42_;
1347                         gboolean _tmp43_ = FALSE;
1348                         gboolean _tmp45_;
1349                         gboolean _tmp49_;
1350                         GCompareFunc _tmp50_;
1351                         GCompareFunc _tmp51_;
1352                         gconstpointer _tmp52_;
1353                         GeeTreeSetNode* _tmp53_;
1354                         gconstpointer _tmp54_;
1355                         gint _tmp55_ = 0;
1356                         _tmp22_ = *node;
1357                         _tmp23_ = _tmp22_->left;
1358                         _tmp24_ = gee_tree_set_is_red (self, _tmp23_);
1359                         if (_tmp24_) {
1360                                 gee_tree_set_rotate_right (self, node);
1361                         }
1362                         _tmp25_ = *node;
1363                         _tmp26_ = _tmp25_->right;
1364                         r = _tmp26_;
1365                         _tmp28_ = gee_tree_set_get_compare_func (self);
1366                         _tmp29_ = _tmp28_;
1367                         _tmp30_ = item;
1368                         _tmp31_ = *node;
1369                         _tmp32_ = _tmp31_->key;
1370                         _tmp33_ = _tmp29_ (_tmp30_, _tmp32_);
1371                         if (_tmp33_ == 0) {
1372                                 GeeTreeSetNode* _tmp34_;
1373                                 _tmp34_ = r;
1374                                 _tmp27_ = _tmp34_ == NULL;
1375                         } else {
1376                                 _tmp27_ = FALSE;
1377                         }
1378                         _tmp35_ = _tmp27_;
1379                         if (_tmp35_) {
1380                                 if ((&_vala_prev) != NULL) {
1381                                         GeeTreeSetNode* _tmp36_;
1382                                         GeeTreeSetNode* _tmp37_;
1383                                         _tmp36_ = *node;
1384                                         _tmp37_ = _tmp36_->prev;
1385                                         _vala_prev = _tmp37_;
1386                                 }
1387                                 if ((&_vala_next) != NULL) {
1388                                         GeeTreeSetNode* _tmp38_;
1389                                         GeeTreeSetNode* _tmp39_;
1390                                         _tmp38_ = *node;
1391                                         _tmp39_ = _tmp38_->next;
1392                                         _vala_next = _tmp39_;
1393                                 }
1394                                 gee_tree_set_fix_removal (self, node, NULL);
1395                                 result = TRUE;
1396                                 if (prev) {
1397                                         *prev = _vala_prev;
1398                                 }
1399                                 if (next) {
1400                                         *next = _vala_next;
1401                                 }
1402                                 return result;
1403                         }
1404                         _tmp42_ = r;
1405                         _tmp43_ = gee_tree_set_is_black (self, _tmp42_);
1406                         if (_tmp43_) {
1407                                 GeeTreeSetNode* _tmp44_;
1408                                 _tmp44_ = r;
1409                                 _tmp41_ = _tmp44_ != NULL;
1410                         } else {
1411                                 _tmp41_ = FALSE;
1412                         }
1413                         _tmp45_ = _tmp41_;
1414                         if (_tmp45_) {
1415                                 GeeTreeSetNode* _tmp46_;
1416                                 GeeTreeSetNode* _tmp47_;
1417                                 gboolean _tmp48_ = FALSE;
1418                                 _tmp46_ = r;
1419                                 _tmp47_ = _tmp46_->left;
1420                                 _tmp48_ = gee_tree_set_is_black (self, _tmp47_);
1421                                 _tmp40_ = _tmp48_;
1422                         } else {
1423                                 _tmp40_ = FALSE;
1424                         }
1425                         _tmp49_ = _tmp40_;
1426                         if (_tmp49_) {
1427                                 gee_tree_set_move_red_right (self, node);
1428                         }
1429                         _tmp50_ = gee_tree_set_get_compare_func (self);
1430                         _tmp51_ = _tmp50_;
1431                         _tmp52_ = item;
1432                         _tmp53_ = *node;
1433                         _tmp54_ = _tmp53_->key;
1434                         _tmp55_ = _tmp51_ (_tmp52_, _tmp54_);
1435                         if (_tmp55_ == 0) {
1436                                 GeeTreeSetNode* _tmp59_;
1437                                 GeeTreeSetNode* _tmp60_;
1438                                 gpointer _tmp61_ = NULL;
1439                                 if ((&_vala_prev) != NULL) {
1440                                         GeeTreeSetNode* _tmp56_;
1441                                         GeeTreeSetNode* _tmp57_;
1442                                         _tmp56_ = *node;
1443                                         _tmp57_ = _tmp56_->prev;
1444                                         _vala_prev = _tmp57_;
1445                                 }
1446                                 if ((&_vala_next) != NULL) {
1447                                         GeeTreeSetNode* _tmp58_;
1448                                         _tmp58_ = *node;
1449                                         _vala_next = _tmp58_;
1450                                 }
1451                                 _tmp59_ = *node;
1452                                 _tmp60_ = *node;
1453                                 gee_tree_set_remove_minimal (self, &_tmp59_->right, &_tmp61_);
1454                                 ((_tmp60_->key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp60_->key = (self->priv->g_destroy_func (_tmp60_->key), NULL));
1455                                 _tmp60_->key = _tmp61_;
1456                                 gee_tree_set_fix_up (self, node);
1457                                 result = TRUE;
1458                                 if (prev) {
1459                                         *prev = _vala_prev;
1460                                 }
1461                                 if (next) {
1462                                         *next = _vala_next;
1463                                 }
1464                                 return result;
1465                         } else {
1466                                 GeeTreeSetNode* _tmp62_;
1467                                 gconstpointer _tmp63_;
1468                                 GeeTreeSetNode* _tmp64_ = NULL;
1469                                 GeeTreeSetNode* _tmp65_ = NULL;
1470                                 gboolean _tmp66_ = FALSE;
1471                                 gboolean re;
1472                                 _tmp62_ = *node;
1473                                 _tmp63_ = item;
1474                                 _tmp66_ = gee_tree_set_remove_from_node (self, &_tmp62_->right, _tmp63_, &_tmp64_, &_tmp65_);
1475                                 _vala_prev = _tmp64_;
1476                                 _vala_next = _tmp65_;
1477                                 re = _tmp66_;
1478                                 gee_tree_set_fix_up (self, node);
1479                                 result = re;
1480                                 if (prev) {
1481                                         *prev = _vala_prev;
1482                                 }
1483                                 if (next) {
1484                                         *next = _vala_next;
1485                                 }
1486                                 return result;
1487                         }
1488                 }
1489         }
1490         if (prev) {
1491                 *prev = _vala_prev;
1492         }
1493         if (next) {
1494                 *next = _vala_next;
1495         }
1496 }
1497
1498
1499 /**
1500  * {@inheritDoc}
1501  */
1502 static gboolean gee_tree_set_real_remove (GeeAbstractCollection* base, gconstpointer item) {
1503         GeeTreeSet * self;
1504         gboolean result = FALSE;
1505         gconstpointer _tmp0_;
1506         gboolean _tmp1_ = FALSE;
1507         gboolean b;
1508         GeeTreeSetNode* _tmp2_;
1509         gint _tmp4_;
1510         self = (GeeTreeSet*) base;
1511         _tmp0_ = item;
1512         _tmp1_ = gee_tree_set_remove_from_node (self, &self->priv->root, _tmp0_, NULL, NULL);
1513         b = _tmp1_;
1514         _tmp2_ = self->priv->root;
1515         if (_tmp2_ != NULL) {
1516                 GeeTreeSetNode* _tmp3_;
1517                 _tmp3_ = self->priv->root;
1518                 _tmp3_->color = GEE_TREE_SET_NODE_COLOR_BLACK;
1519         }
1520         _tmp4_ = self->priv->stamp;
1521         self->priv->stamp = _tmp4_ + 1;
1522         result = b;
1523         return result;
1524 }
1525
1526
1527 static inline void gee_tree_set_clear_subtree (GeeTreeSet* self, GeeTreeSetNode* node) {
1528         GeeTreeSetNode* _tmp0_;
1529         GeeTreeSetNode* _tmp1_;
1530         GeeTreeSetNode* _tmp2_;
1531         GeeTreeSetNode* _tmp5_;
1532         GeeTreeSetNode* _tmp6_;
1533         g_return_if_fail (self != NULL);
1534         g_return_if_fail (node != NULL);
1535         _tmp0_ = node;
1536         ((_tmp0_->key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp0_->key = (self->priv->g_destroy_func (_tmp0_->key), NULL));
1537         _tmp0_->key = NULL;
1538         _tmp1_ = node;
1539         _tmp2_ = _tmp1_->left;
1540         if (_tmp2_ != NULL) {
1541                 GeeTreeSetNode* _tmp3_;
1542                 GeeTreeSetNode* _tmp4_;
1543                 _tmp3_ = node;
1544                 _tmp4_ = _tmp3_->left;
1545                 _tmp3_->left = NULL;
1546                 gee_tree_set_clear_subtree (self, _tmp4_);
1547         }
1548         _tmp5_ = node;
1549         _tmp6_ = _tmp5_->right;
1550         if (_tmp6_ != NULL) {
1551                 GeeTreeSetNode* _tmp7_;
1552                 GeeTreeSetNode* _tmp8_;
1553                 _tmp7_ = node;
1554                 _tmp8_ = _tmp7_->right;
1555                 _tmp7_->right = NULL;
1556                 gee_tree_set_clear_subtree (self, _tmp8_);
1557         }
1558         _gee_tree_set_node_free0 (node);
1559 }
1560
1561
1562 /**
1563  * {@inheritDoc}
1564  */
1565 static void gee_tree_set_real_clear (GeeAbstractCollection* base) {
1566         GeeTreeSet * self;
1567         GeeTreeSetNode* _tmp0_;
1568         gint _tmp3_;
1569         self = (GeeTreeSet*) base;
1570         _tmp0_ = self->priv->root;
1571         if (_tmp0_ != NULL) {
1572                 GeeTreeSetNode* _tmp1_;
1573                 GeeTreeSetNode* _tmp2_;
1574                 _tmp1_ = self->priv->root;
1575                 self->priv->root = NULL;
1576                 gee_tree_set_clear_subtree (self, _tmp1_);
1577                 self->priv->_last = NULL;
1578                 _tmp2_ = self->priv->_last;
1579                 self->priv->_first = _tmp2_;
1580         }
1581         self->priv->_size = 0;
1582         _tmp3_ = self->priv->stamp;
1583         self->priv->stamp = _tmp3_ + 1;
1584 }
1585
1586
1587 /**
1588  * {@inheritDoc}
1589  */
1590 static GeeIterator* gee_tree_set_real_iterator (GeeAbstractCollection* base) {
1591         GeeTreeSet * self;
1592         GeeIterator* result = NULL;
1593         GeeTreeSetIterator* _tmp0_;
1594         self = (GeeTreeSet*) base;
1595         _tmp0_ = gee_tree_set_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
1596         result = (GeeIterator*) _tmp0_;
1597         return result;
1598 }
1599
1600
1601 /**
1602  * {@inheritDoc}
1603  */
1604 static GeeBidirIterator* gee_tree_set_real_bidir_iterator (GeeSortedSet* base) {
1605         GeeTreeSet * self;
1606         GeeBidirIterator* result = NULL;
1607         GeeTreeSetIterator* _tmp0_;
1608         self = (GeeTreeSet*) base;
1609         _tmp0_ = gee_tree_set_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
1610         result = (GeeBidirIterator*) _tmp0_;
1611         return result;
1612 }
1613
1614
1615 static inline gpointer gee_tree_set_lift_null_get (GeeTreeSet* self, GeeTreeSetNode* node) {
1616         gpointer result = NULL;
1617         gconstpointer _tmp0_ = NULL;
1618         GeeTreeSetNode* _tmp1_;
1619         gconstpointer _tmp4_;
1620         gpointer _tmp5_;
1621         g_return_val_if_fail (self != NULL, NULL);
1622         _tmp1_ = node;
1623         if (_tmp1_ != NULL) {
1624                 GeeTreeSetNode* _tmp2_;
1625                 gconstpointer _tmp3_;
1626                 _tmp2_ = node;
1627                 _tmp3_ = _tmp2_->key;
1628                 _tmp0_ = _tmp3_;
1629         } else {
1630                 _tmp0_ = NULL;
1631         }
1632         _tmp4_ = _tmp0_;
1633         _tmp5_ = ((_tmp4_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp4_) : ((gpointer) _tmp4_);
1634         result = _tmp5_;
1635         return result;
1636 }
1637
1638
1639 /**
1640  * {@inheritDoc}
1641  */
1642 static gpointer gee_tree_set_real_first (GeeSortedSet* base) {
1643         GeeTreeSet * self;
1644         gpointer result = NULL;
1645         GeeTreeSetNode* _tmp0_;
1646         GeeTreeSetNode* _tmp1_;
1647         gconstpointer _tmp2_;
1648         gpointer _tmp3_;
1649         self = (GeeTreeSet*) base;
1650         _tmp0_ = self->priv->_first;
1651         _vala_assert (_tmp0_ != NULL, "_first != null");
1652         _tmp1_ = self->priv->_first;
1653         _tmp2_ = _tmp1_->key;
1654         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
1655         result = _tmp3_;
1656         return result;
1657 }
1658
1659
1660 /**
1661  * {@inheritDoc}
1662  */
1663 static gpointer gee_tree_set_real_last (GeeSortedSet* base) {
1664         GeeTreeSet * self;
1665         gpointer result = NULL;
1666         GeeTreeSetNode* _tmp0_;
1667         GeeTreeSetNode* _tmp1_;
1668         gconstpointer _tmp2_;
1669         gpointer _tmp3_;
1670         self = (GeeTreeSet*) base;
1671         _tmp0_ = self->priv->_last;
1672         _vala_assert (_tmp0_ != NULL, "_last != null");
1673         _tmp1_ = self->priv->_last;
1674         _tmp2_ = _tmp1_->key;
1675         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
1676         result = _tmp3_;
1677         return result;
1678 }
1679
1680
1681 /**
1682  * {@inheritDoc}
1683  */
1684 static GeeSortedSet* gee_tree_set_real_head_set (GeeSortedSet* base, gconstpointer before) {
1685         GeeTreeSet * self;
1686         GeeSortedSet* result = NULL;
1687         gconstpointer _tmp0_;
1688         GeeTreeSetSubSet* _tmp1_;
1689         self = (GeeTreeSet*) base;
1690         _tmp0_ = before;
1691         _tmp1_ = gee_tree_set_sub_set_new_head (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp0_);
1692         result = (GeeSortedSet*) _tmp1_;
1693         return result;
1694 }
1695
1696
1697 /**
1698  * {@inheritDoc}
1699  */
1700 static GeeSortedSet* gee_tree_set_real_tail_set (GeeSortedSet* base, gconstpointer after) {
1701         GeeTreeSet * self;
1702         GeeSortedSet* result = NULL;
1703         gconstpointer _tmp0_;
1704         GeeTreeSetSubSet* _tmp1_;
1705         self = (GeeTreeSet*) base;
1706         _tmp0_ = after;
1707         _tmp1_ = gee_tree_set_sub_set_new_tail (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp0_);
1708         result = (GeeSortedSet*) _tmp1_;
1709         return result;
1710 }
1711
1712
1713 /**
1714  * {@inheritDoc}
1715  */
1716 static GeeSortedSet* gee_tree_set_real_sub_set (GeeSortedSet* base, gconstpointer after, gconstpointer before) {
1717         GeeTreeSet * self;
1718         GeeSortedSet* result = NULL;
1719         gconstpointer _tmp0_;
1720         gconstpointer _tmp1_;
1721         GeeTreeSetSubSet* _tmp2_;
1722         self = (GeeTreeSet*) base;
1723         _tmp0_ = after;
1724         _tmp1_ = before;
1725         _tmp2_ = gee_tree_set_sub_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp0_, _tmp1_);
1726         result = (GeeSortedSet*) _tmp2_;
1727         return result;
1728 }
1729
1730
1731 static inline GeeTreeSetNode* gee_tree_set_find_node (GeeTreeSet* self, gconstpointer item) {
1732         GeeTreeSetNode* result = NULL;
1733         GeeTreeSetNode* _tmp0_;
1734         GeeTreeSetNode* cur;
1735         g_return_val_if_fail (self != NULL, NULL);
1736         _tmp0_ = self->priv->root;
1737         cur = _tmp0_;
1738         while (TRUE) {
1739                 GeeTreeSetNode* _tmp1_;
1740                 GCompareFunc _tmp2_;
1741                 GCompareFunc _tmp3_;
1742                 gconstpointer _tmp4_;
1743                 GeeTreeSetNode* _tmp5_;
1744                 gconstpointer _tmp6_;
1745                 gint _tmp7_ = 0;
1746                 gint res;
1747                 gint _tmp8_;
1748                 _tmp1_ = cur;
1749                 if (!(_tmp1_ != NULL)) {
1750                         break;
1751                 }
1752                 _tmp2_ = gee_tree_set_get_compare_func (self);
1753                 _tmp3_ = _tmp2_;
1754                 _tmp4_ = item;
1755                 _tmp5_ = cur;
1756                 _tmp6_ = _tmp5_->key;
1757                 _tmp7_ = _tmp3_ (_tmp4_, _tmp6_);
1758                 res = _tmp7_;
1759                 _tmp8_ = res;
1760                 if (_tmp8_ == 0) {
1761                         GeeTreeSetNode* _tmp9_;
1762                         _tmp9_ = cur;
1763                         result = _tmp9_;
1764                         return result;
1765                 } else {
1766                         gint _tmp10_;
1767                         _tmp10_ = res;
1768                         if (_tmp10_ < 0) {
1769                                 GeeTreeSetNode* _tmp11_;
1770                                 GeeTreeSetNode* _tmp12_;
1771                                 _tmp11_ = cur;
1772                                 _tmp12_ = _tmp11_->left;
1773                                 cur = _tmp12_;
1774                         } else {
1775                                 GeeTreeSetNode* _tmp13_;
1776                                 GeeTreeSetNode* _tmp14_;
1777                                 _tmp13_ = cur;
1778                                 _tmp14_ = _tmp13_->right;
1779                                 cur = _tmp14_;
1780                         }
1781                 }
1782         }
1783         result = NULL;
1784         return result;
1785 }
1786
1787
1788 /**
1789  * {@inheritDoc}
1790  */
1791 static GeeBidirIterator* gee_tree_set_real_iterator_at (GeeSortedSet* base, gconstpointer item) {
1792         GeeTreeSet * self;
1793         GeeBidirIterator* result = NULL;
1794         gconstpointer _tmp0_;
1795         GeeTreeSetNode* _tmp1_ = NULL;
1796         GeeTreeSetNode* node;
1797         GeeTreeSetIterator* _tmp2_ = NULL;
1798         GeeTreeSetNode* _tmp3_;
1799         self = (GeeTreeSet*) base;
1800         _tmp0_ = item;
1801         _tmp1_ = gee_tree_set_find_node (self, _tmp0_);
1802         node = _tmp1_;
1803         _tmp3_ = node;
1804         if (_tmp3_ != NULL) {
1805                 GeeTreeSetNode* _tmp4_;
1806                 GeeTreeSetIterator* _tmp5_;
1807                 _tmp4_ = node;
1808                 _tmp5_ = gee_tree_set_iterator_new_pointing (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp4_);
1809                 _g_object_unref0 (_tmp2_);
1810                 _tmp2_ = _tmp5_;
1811         } else {
1812                 _g_object_unref0 (_tmp2_);
1813                 _tmp2_ = NULL;
1814         }
1815         result = (GeeBidirIterator*) _tmp2_;
1816         return result;
1817 }
1818
1819
1820 static inline GeeTreeSetNode* gee_tree_set_find_nearest (GeeTreeSet* self, gconstpointer item) {
1821         GeeTreeSetNode* result = NULL;
1822         GeeTreeSetNode* _tmp0_;
1823         GeeTreeSetNode* cur;
1824         g_return_val_if_fail (self != NULL, NULL);
1825         _tmp0_ = self->priv->root;
1826         cur = _tmp0_;
1827         while (TRUE) {
1828                 GeeTreeSetNode* _tmp1_;
1829                 GCompareFunc _tmp2_;
1830                 GCompareFunc _tmp3_;
1831                 gconstpointer _tmp4_;
1832                 GeeTreeSetNode* _tmp5_;
1833                 gconstpointer _tmp6_;
1834                 gint _tmp7_ = 0;
1835                 gint res;
1836                 gint _tmp8_;
1837                 _tmp1_ = cur;
1838                 if (!(_tmp1_ != NULL)) {
1839                         break;
1840                 }
1841                 _tmp2_ = gee_tree_set_get_compare_func (self);
1842                 _tmp3_ = _tmp2_;
1843                 _tmp4_ = item;
1844                 _tmp5_ = cur;
1845                 _tmp6_ = _tmp5_->key;
1846                 _tmp7_ = _tmp3_ (_tmp4_, _tmp6_);
1847                 res = _tmp7_;
1848                 _tmp8_ = res;
1849                 if (_tmp8_ == 0) {
1850                         GeeTreeSetNode* _tmp9_;
1851                         _tmp9_ = cur;
1852                         result = _tmp9_;
1853                         return result;
1854                 } else {
1855                         gint _tmp10_;
1856                         _tmp10_ = res;
1857                         if (_tmp10_ < 0) {
1858                                 GeeTreeSetNode* _tmp11_;
1859                                 GeeTreeSetNode* _tmp12_;
1860                                 GeeTreeSetNode* _tmp14_;
1861                                 GeeTreeSetNode* _tmp15_;
1862                                 _tmp11_ = cur;
1863                                 _tmp12_ = _tmp11_->left;
1864                                 if (_tmp12_ == NULL) {
1865                                         GeeTreeSetNode* _tmp13_;
1866                                         _tmp13_ = cur;
1867                                         result = _tmp13_;
1868                                         return result;
1869                                 }
1870                                 _tmp14_ = cur;
1871                                 _tmp15_ = _tmp14_->left;
1872                                 cur = _tmp15_;
1873                         } else {
1874                                 GeeTreeSetNode* _tmp16_;
1875                                 GeeTreeSetNode* _tmp17_;
1876                                 GeeTreeSetNode* _tmp19_;
1877                                 GeeTreeSetNode* _tmp20_;
1878                                 _tmp16_ = cur;
1879                                 _tmp17_ = _tmp16_->right;
1880                                 if (_tmp17_ == NULL) {
1881                                         GeeTreeSetNode* _tmp18_;
1882                                         _tmp18_ = cur;
1883                                         result = _tmp18_;
1884                                         return result;
1885                                 }
1886                                 _tmp19_ = cur;
1887                                 _tmp20_ = _tmp19_->right;
1888                                 cur = _tmp20_;
1889                         }
1890                 }
1891         }
1892         result = NULL;
1893         return result;
1894 }
1895
1896
1897 static inline GeeTreeSetNode* gee_tree_set_find_lower (GeeTreeSet* self, gconstpointer item) {
1898         GeeTreeSetNode* result = NULL;
1899         gconstpointer _tmp0_;
1900         GeeTreeSetNode* _tmp1_ = NULL;
1901         GeeTreeSetNode* node;
1902         GeeTreeSetNode* _tmp2_;
1903         GeeTreeSetNode* _tmp3_ = NULL;
1904         GCompareFunc _tmp4_;
1905         GCompareFunc _tmp5_;
1906         gconstpointer _tmp6_;
1907         GeeTreeSetNode* _tmp7_;
1908         gconstpointer _tmp8_;
1909         gint _tmp9_ = 0;
1910         GeeTreeSetNode* _tmp13_;
1911         g_return_val_if_fail (self != NULL, NULL);
1912         _tmp0_ = item;
1913         _tmp1_ = gee_tree_set_find_nearest (self, _tmp0_);
1914         node = _tmp1_;
1915         _tmp2_ = node;
1916         if (_tmp2_ == NULL) {
1917                 result = NULL;
1918                 return result;
1919         }
1920         _tmp4_ = gee_tree_set_get_compare_func (self);
1921         _tmp5_ = _tmp4_;
1922         _tmp6_ = item;
1923         _tmp7_ = node;
1924         _tmp8_ = _tmp7_->key;
1925         _tmp9_ = _tmp5_ (_tmp6_, _tmp8_);
1926         if (_tmp9_ <= 0) {
1927                 GeeTreeSetNode* _tmp10_;
1928                 GeeTreeSetNode* _tmp11_;
1929                 _tmp10_ = node;
1930                 _tmp11_ = _tmp10_->prev;
1931                 _tmp3_ = _tmp11_;
1932         } else {
1933                 GeeTreeSetNode* _tmp12_;
1934                 _tmp12_ = node;
1935                 _tmp3_ = _tmp12_;
1936         }
1937         _tmp13_ = _tmp3_;
1938         result = _tmp13_;
1939         return result;
1940 }
1941
1942
1943 static inline GeeTreeSetNode* gee_tree_set_find_higher (GeeTreeSet* self, gconstpointer item) {
1944         GeeTreeSetNode* result = NULL;
1945         gconstpointer _tmp0_;
1946         GeeTreeSetNode* _tmp1_ = NULL;
1947         GeeTreeSetNode* node;
1948         GeeTreeSetNode* _tmp2_;
1949         GeeTreeSetNode* _tmp3_ = NULL;
1950         GCompareFunc _tmp4_;
1951         GCompareFunc _tmp5_;
1952         gconstpointer _tmp6_;
1953         GeeTreeSetNode* _tmp7_;
1954         gconstpointer _tmp8_;
1955         gint _tmp9_ = 0;
1956         GeeTreeSetNode* _tmp13_;
1957         g_return_val_if_fail (self != NULL, NULL);
1958         _tmp0_ = item;
1959         _tmp1_ = gee_tree_set_find_nearest (self, _tmp0_);
1960         node = _tmp1_;
1961         _tmp2_ = node;
1962         if (_tmp2_ == NULL) {
1963                 result = NULL;
1964                 return result;
1965         }
1966         _tmp4_ = gee_tree_set_get_compare_func (self);
1967         _tmp5_ = _tmp4_;
1968         _tmp6_ = item;
1969         _tmp7_ = node;
1970         _tmp8_ = _tmp7_->key;
1971         _tmp9_ = _tmp5_ (_tmp6_, _tmp8_);
1972         if (_tmp9_ >= 0) {
1973                 GeeTreeSetNode* _tmp10_;
1974                 GeeTreeSetNode* _tmp11_;
1975                 _tmp10_ = node;
1976                 _tmp11_ = _tmp10_->next;
1977                 _tmp3_ = _tmp11_;
1978         } else {
1979                 GeeTreeSetNode* _tmp12_;
1980                 _tmp12_ = node;
1981                 _tmp3_ = _tmp12_;
1982         }
1983         _tmp13_ = _tmp3_;
1984         result = _tmp13_;
1985         return result;
1986 }
1987
1988
1989 static inline GeeTreeSetNode* gee_tree_set_find_floor (GeeTreeSet* self, gconstpointer item) {
1990         GeeTreeSetNode* result = NULL;
1991         gconstpointer _tmp0_;
1992         GeeTreeSetNode* _tmp1_ = NULL;
1993         GeeTreeSetNode* node;
1994         GeeTreeSetNode* _tmp2_;
1995         GeeTreeSetNode* _tmp3_ = NULL;
1996         GCompareFunc _tmp4_;
1997         GCompareFunc _tmp5_;
1998         gconstpointer _tmp6_;
1999         GeeTreeSetNode* _tmp7_;
2000         gconstpointer _tmp8_;
2001         gint _tmp9_ = 0;
2002         GeeTreeSetNode* _tmp13_;
2003         g_return_val_if_fail (self != NULL, NULL);
2004         _tmp0_ = item;
2005         _tmp1_ = gee_tree_set_find_nearest (self, _tmp0_);
2006         node = _tmp1_;
2007         _tmp2_ = node;
2008         if (_tmp2_ == NULL) {
2009                 result = NULL;
2010                 return result;
2011         }
2012         _tmp4_ = gee_tree_set_get_compare_func (self);
2013         _tmp5_ = _tmp4_;
2014         _tmp6_ = item;
2015         _tmp7_ = node;
2016         _tmp8_ = _tmp7_->key;
2017         _tmp9_ = _tmp5_ (_tmp6_, _tmp8_);
2018         if (_tmp9_ < 0) {
2019                 GeeTreeSetNode* _tmp10_;
2020                 GeeTreeSetNode* _tmp11_;
2021                 _tmp10_ = node;
2022                 _tmp11_ = _tmp10_->prev;
2023                 _tmp3_ = _tmp11_;
2024         } else {
2025                 GeeTreeSetNode* _tmp12_;
2026                 _tmp12_ = node;
2027                 _tmp3_ = _tmp12_;
2028         }
2029         _tmp13_ = _tmp3_;
2030         result = _tmp13_;
2031         return result;
2032 }
2033
2034
2035 static inline GeeTreeSetNode* gee_tree_set_find_ceil (GeeTreeSet* self, gconstpointer item) {
2036         GeeTreeSetNode* result = NULL;
2037         gconstpointer _tmp0_;
2038         GeeTreeSetNode* _tmp1_ = NULL;
2039         GeeTreeSetNode* node;
2040         GeeTreeSetNode* _tmp2_;
2041         GeeTreeSetNode* _tmp3_ = NULL;
2042         GCompareFunc _tmp4_;
2043         GCompareFunc _tmp5_;
2044         gconstpointer _tmp6_;
2045         GeeTreeSetNode* _tmp7_;
2046         gconstpointer _tmp8_;
2047         gint _tmp9_ = 0;
2048         GeeTreeSetNode* _tmp13_;
2049         g_return_val_if_fail (self != NULL, NULL);
2050         _tmp0_ = item;
2051         _tmp1_ = gee_tree_set_find_nearest (self, _tmp0_);
2052         node = _tmp1_;
2053         _tmp2_ = node;
2054         if (_tmp2_ == NULL) {
2055                 result = NULL;
2056                 return result;
2057         }
2058         _tmp4_ = gee_tree_set_get_compare_func (self);
2059         _tmp5_ = _tmp4_;
2060         _tmp6_ = item;
2061         _tmp7_ = node;
2062         _tmp8_ = _tmp7_->key;
2063         _tmp9_ = _tmp5_ (_tmp6_, _tmp8_);
2064         if (_tmp9_ > 0) {
2065                 GeeTreeSetNode* _tmp10_;
2066                 GeeTreeSetNode* _tmp11_;
2067                 _tmp10_ = node;
2068                 _tmp11_ = _tmp10_->next;
2069                 _tmp3_ = _tmp11_;
2070         } else {
2071                 GeeTreeSetNode* _tmp12_;
2072                 _tmp12_ = node;
2073                 _tmp3_ = _tmp12_;
2074         }
2075         _tmp13_ = _tmp3_;
2076         result = _tmp13_;
2077         return result;
2078 }
2079
2080
2081 /**
2082  * {@inheritDoc}
2083  */
2084 static gpointer gee_tree_set_real_lower (GeeSortedSet* base, gconstpointer item) {
2085         GeeTreeSet * self;
2086         gpointer result = NULL;
2087         gconstpointer _tmp0_;
2088         GeeTreeSetNode* _tmp1_ = NULL;
2089         gpointer _tmp2_ = NULL;
2090         self = (GeeTreeSet*) base;
2091         _tmp0_ = item;
2092         _tmp1_ = gee_tree_set_find_lower (self, _tmp0_);
2093         _tmp2_ = gee_tree_set_lift_null_get (self, _tmp1_);
2094         result = _tmp2_;
2095         return result;
2096 }
2097
2098
2099 /**
2100  * {@inheritDoc}
2101  */
2102 static gpointer gee_tree_set_real_higher (GeeSortedSet* base, gconstpointer item) {
2103         GeeTreeSet * self;
2104         gpointer result = NULL;
2105         gconstpointer _tmp0_;
2106         GeeTreeSetNode* _tmp1_ = NULL;
2107         gpointer _tmp2_ = NULL;
2108         self = (GeeTreeSet*) base;
2109         _tmp0_ = item;
2110         _tmp1_ = gee_tree_set_find_higher (self, _tmp0_);
2111         _tmp2_ = gee_tree_set_lift_null_get (self, _tmp1_);
2112         result = _tmp2_;
2113         return result;
2114 }
2115
2116
2117 /**
2118  * {@inheritDoc}
2119  */
2120 static gpointer gee_tree_set_real_floor (GeeSortedSet* base, gconstpointer item) {
2121         GeeTreeSet * self;
2122         gpointer result = NULL;
2123         gconstpointer _tmp0_;
2124         GeeTreeSetNode* _tmp1_ = NULL;
2125         gpointer _tmp2_ = NULL;
2126         self = (GeeTreeSet*) base;
2127         _tmp0_ = item;
2128         _tmp1_ = gee_tree_set_find_floor (self, _tmp0_);
2129         _tmp2_ = gee_tree_set_lift_null_get (self, _tmp1_);
2130         result = _tmp2_;
2131         return result;
2132 }
2133
2134
2135 /**
2136  * {@inheritDoc}
2137  */
2138 static gpointer gee_tree_set_real_ceil (GeeSortedSet* base, gconstpointer item) {
2139         GeeTreeSet * self;
2140         gpointer result = NULL;
2141         gconstpointer _tmp0_;
2142         GeeTreeSetNode* _tmp1_ = NULL;
2143         gpointer _tmp2_ = NULL;
2144         self = (GeeTreeSet*) base;
2145         _tmp0_ = item;
2146         _tmp1_ = gee_tree_set_find_ceil (self, _tmp0_);
2147         _tmp2_ = gee_tree_set_lift_null_get (self, _tmp1_);
2148         result = _tmp2_;
2149         return result;
2150 }
2151
2152
2153 static inline gpointer gee_tree_set_min (GeeTreeSet* self, gconstpointer a, gconstpointer b) {
2154         gpointer result = NULL;
2155         gconstpointer _tmp0_ = NULL;
2156         GCompareFunc _tmp1_;
2157         GCompareFunc _tmp2_;
2158         gconstpointer _tmp3_;
2159         gconstpointer _tmp4_;
2160         gint _tmp5_ = 0;
2161         gconstpointer _tmp8_;
2162         gpointer _tmp9_;
2163         g_return_val_if_fail (self != NULL, NULL);
2164         _tmp1_ = gee_tree_set_get_compare_func (self);
2165         _tmp2_ = _tmp1_;
2166         _tmp3_ = a;
2167         _tmp4_ = b;
2168         _tmp5_ = _tmp2_ (_tmp3_, _tmp4_);
2169         if (_tmp5_ <= 0) {
2170                 gconstpointer _tmp6_;
2171                 _tmp6_ = a;
2172                 _tmp0_ = _tmp6_;
2173         } else {
2174                 gconstpointer _tmp7_;
2175                 _tmp7_ = b;
2176                 _tmp0_ = _tmp7_;
2177         }
2178         _tmp8_ = _tmp0_;
2179         _tmp9_ = ((_tmp8_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
2180         result = _tmp9_;
2181         return result;
2182 }
2183
2184
2185 static inline gpointer gee_tree_set_max (GeeTreeSet* self, gconstpointer a, gconstpointer b) {
2186         gpointer result = NULL;
2187         gconstpointer _tmp0_ = NULL;
2188         GCompareFunc _tmp1_;
2189         GCompareFunc _tmp2_;
2190         gconstpointer _tmp3_;
2191         gconstpointer _tmp4_;
2192         gint _tmp5_ = 0;
2193         gconstpointer _tmp8_;
2194         gpointer _tmp9_;
2195         g_return_val_if_fail (self != NULL, NULL);
2196         _tmp1_ = gee_tree_set_get_compare_func (self);
2197         _tmp2_ = _tmp1_;
2198         _tmp3_ = a;
2199         _tmp4_ = b;
2200         _tmp5_ = _tmp2_ (_tmp3_, _tmp4_);
2201         if (_tmp5_ > 0) {
2202                 gconstpointer _tmp6_;
2203                 _tmp6_ = a;
2204                 _tmp0_ = _tmp6_;
2205         } else {
2206                 gconstpointer _tmp7_;
2207                 _tmp7_ = b;
2208                 _tmp0_ = _tmp7_;
2209         }
2210         _tmp8_ = _tmp0_;
2211         _tmp9_ = ((_tmp8_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
2212         result = _tmp9_;
2213         return result;
2214 }
2215
2216
2217 static gint gee_tree_set_real_get_size (GeeAbstractCollection* base) {
2218         gint result;
2219         GeeTreeSet* self;
2220         gint _tmp0_;
2221         self = (GeeTreeSet*) base;
2222         _tmp0_ = self->priv->_size;
2223         result = _tmp0_;
2224         return result;
2225 }
2226
2227
2228 GCompareFunc gee_tree_set_get_compare_func (GeeTreeSet* self) {
2229         GCompareFunc result;
2230         GCompareFunc _tmp0_;
2231         g_return_val_if_fail (self != NULL, NULL);
2232         _tmp0_ = self->priv->_compare_func;
2233         result = _tmp0_;
2234         return result;
2235 }
2236
2237
2238 static void gee_tree_set_set_compare_func (GeeTreeSet* self, GCompareFunc value) {
2239         GCompareFunc _tmp0_;
2240         g_return_if_fail (self != NULL);
2241         _tmp0_ = value;
2242         self->priv->_compare_func = _tmp0_;
2243         g_object_notify ((GObject *) self, "compare-func");
2244 }
2245
2246
2247 static GeeTreeSetNodeColor gee_tree_set_node_color_flip (GeeTreeSetNodeColor self) {
2248         GeeTreeSetNodeColor result = 0;
2249         if (self == GEE_TREE_SET_NODE_COLOR_RED) {
2250                 result = GEE_TREE_SET_NODE_COLOR_BLACK;
2251                 return result;
2252         } else {
2253                 result = GEE_TREE_SET_NODE_COLOR_RED;
2254                 return result;
2255         }
2256 }
2257
2258
2259 GType gee_tree_set_node_color_get_type (void) {
2260         static volatile gsize gee_tree_set_node_color_type_id__volatile = 0;
2261         if (g_once_init_enter (&gee_tree_set_node_color_type_id__volatile)) {
2262                 static const GEnumValue values[] = {{GEE_TREE_SET_NODE_COLOR_RED, "GEE_TREE_SET_NODE_COLOR_RED", "red"}, {GEE_TREE_SET_NODE_COLOR_BLACK, "GEE_TREE_SET_NODE_COLOR_BLACK", "black"}, {0, NULL, NULL}};
2263                 GType gee_tree_set_node_color_type_id;
2264                 gee_tree_set_node_color_type_id = g_enum_register_static ("GeeTreeSetNodeColor", values);
2265                 g_once_init_leave (&gee_tree_set_node_color_type_id__volatile, gee_tree_set_node_color_type_id);
2266         }
2267         return gee_tree_set_node_color_type_id__volatile;
2268 }
2269
2270
2271 static GeeTreeSetNode* gee_tree_set_node_new (gpointer node, GeeTreeSetNode* prev, GeeTreeSetNode* next) {
2272         GeeTreeSetNode* self;
2273         gpointer _tmp0_;
2274         GeeTreeSetNode* _tmp1_;
2275         GeeTreeSetNode* _tmp2_;
2276         GeeTreeSetNode* _tmp3_;
2277         GeeTreeSetNode* _tmp5_;
2278         self = g_slice_new0 (GeeTreeSetNode);
2279         gee_tree_set_node_instance_init (self);
2280         _tmp0_ = node;
2281         node = NULL;
2282         self->key = _tmp0_;
2283         self->color = GEE_TREE_SET_NODE_COLOR_RED;
2284         _tmp1_ = prev;
2285         self->prev = _tmp1_;
2286         _tmp2_ = next;
2287         self->next = _tmp2_;
2288         _tmp3_ = prev;
2289         if (_tmp3_ != NULL) {
2290                 GeeTreeSetNode* _tmp4_;
2291                 _tmp4_ = prev;
2292                 _tmp4_->next = self;
2293         }
2294         _tmp5_ = next;
2295         if (_tmp5_ != NULL) {
2296                 GeeTreeSetNode* _tmp6_;
2297                 _tmp6_ = next;
2298                 _tmp6_->prev = self;
2299         }
2300         return self;
2301 }
2302
2303
2304 static void gee_tree_set_node_flip (GeeTreeSetNode* self) {
2305         GeeTreeSetNodeColor _tmp0_;
2306         GeeTreeSetNodeColor _tmp1_ = 0;
2307         GeeTreeSetNode* _tmp2_;
2308         GeeTreeSetNode* _tmp7_;
2309         g_return_if_fail (self != NULL);
2310         _tmp0_ = self->color;
2311         _tmp1_ = gee_tree_set_node_color_flip (_tmp0_);
2312         self->color = _tmp1_;
2313         _tmp2_ = self->left;
2314         if (_tmp2_ != NULL) {
2315                 GeeTreeSetNode* _tmp3_;
2316                 GeeTreeSetNode* _tmp4_;
2317                 GeeTreeSetNodeColor _tmp5_;
2318                 GeeTreeSetNodeColor _tmp6_ = 0;
2319                 _tmp3_ = self->left;
2320                 _tmp4_ = self->left;
2321                 _tmp5_ = _tmp4_->color;
2322                 _tmp6_ = gee_tree_set_node_color_flip (_tmp5_);
2323                 _tmp3_->color = _tmp6_;
2324         }
2325         _tmp7_ = self->right;
2326         if (_tmp7_ != NULL) {
2327                 GeeTreeSetNode* _tmp8_;
2328                 GeeTreeSetNode* _tmp9_;
2329                 GeeTreeSetNodeColor _tmp10_;
2330                 GeeTreeSetNodeColor _tmp11_ = 0;
2331                 _tmp8_ = self->right;
2332                 _tmp9_ = self->right;
2333                 _tmp10_ = _tmp9_->color;
2334                 _tmp11_ = gee_tree_set_node_color_flip (_tmp10_);
2335                 _tmp8_->color = _tmp11_;
2336         }
2337 }
2338
2339
2340 static void gee_tree_set_node_instance_init (GeeTreeSetNode * self) {
2341 }
2342
2343
2344 static void gee_tree_set_node_free (GeeTreeSetNode* self) {
2345         _gee_tree_set_node_free0 (self->left);
2346         _gee_tree_set_node_free0 (self->right);
2347         g_slice_free (GeeTreeSetNode, self);
2348 }
2349
2350
2351 static gpointer _g_object_ref0 (gpointer self) {
2352         return self ? g_object_ref (self) : NULL;
2353 }
2354
2355
2356 static GeeTreeSetIterator* gee_tree_set_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set) {
2357         GeeTreeSetIterator * self = NULL;
2358         GeeTreeSet* _tmp0_;
2359         GeeTreeSet* _tmp1_;
2360         GeeTreeSet* _tmp2_;
2361         gint _tmp3_;
2362         g_return_val_if_fail (set != NULL, NULL);
2363         self = (GeeTreeSetIterator*) g_object_new (object_type, NULL);
2364         self->priv->g_type = g_type;
2365         self->priv->g_dup_func = g_dup_func;
2366         self->priv->g_destroy_func = g_destroy_func;
2367         _tmp0_ = set;
2368         _tmp1_ = _g_object_ref0 (_tmp0_);
2369         _g_object_unref0 (self->priv->_set);
2370         self->priv->_set = _tmp1_;
2371         _tmp2_ = self->priv->_set;
2372         _tmp3_ = _tmp2_->priv->stamp;
2373         self->priv->stamp = _tmp3_;
2374         return self;
2375 }
2376
2377
2378 static GeeTreeSetIterator* gee_tree_set_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set) {
2379         return gee_tree_set_iterator_construct (GEE_TREE_SET_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, set);
2380 }
2381
2382
2383 static GeeTreeSetIterator* gee_tree_set_iterator_construct_pointing (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetNode* current) {
2384         GeeTreeSetIterator * self = NULL;
2385         GeeTreeSet* _tmp0_;
2386         GeeTreeSet* _tmp1_;
2387         GeeTreeSetNode* _tmp2_;
2388         GeeTreeSet* _tmp3_;
2389         gint _tmp4_;
2390         g_return_val_if_fail (set != NULL, NULL);
2391         g_return_val_if_fail (current != NULL, NULL);
2392         self = (GeeTreeSetIterator*) g_object_new (object_type, NULL);
2393         self->priv->g_type = g_type;
2394         self->priv->g_dup_func = g_dup_func;
2395         self->priv->g_destroy_func = g_destroy_func;
2396         _tmp0_ = set;
2397         _tmp1_ = _g_object_ref0 (_tmp0_);
2398         _g_object_unref0 (self->priv->_set);
2399         self->priv->_set = _tmp1_;
2400         _tmp2_ = current;
2401         self->priv->current = _tmp2_;
2402         _tmp3_ = set;
2403         _tmp4_ = _tmp3_->priv->stamp;
2404         self->priv->stamp = _tmp4_;
2405         self->priv->started = TRUE;
2406         return self;
2407 }
2408
2409
2410 static GeeTreeSetIterator* gee_tree_set_iterator_new_pointing (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetNode* current) {
2411         return gee_tree_set_iterator_construct_pointing (GEE_TREE_SET_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, set, current);
2412 }
2413
2414
2415 static gboolean gee_tree_set_iterator_real_next (GeeIterator* base) {
2416         GeeTreeSetIterator * self;
2417         gboolean result = FALSE;
2418         gint _tmp0_;
2419         GeeTreeSet* _tmp1_;
2420         gint _tmp2_;
2421         GeeTreeSetNode* _tmp3_;
2422         self = (GeeTreeSetIterator*) base;
2423         _tmp0_ = self->priv->stamp;
2424         _tmp1_ = self->priv->_set;
2425         _tmp2_ = _tmp1_->priv->stamp;
2426         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2427         _tmp3_ = self->priv->current;
2428         if (_tmp3_ != NULL) {
2429                 GeeTreeSetNode* _tmp4_;
2430                 GeeTreeSetNode* _tmp5_;
2431                 _tmp4_ = self->priv->current;
2432                 _tmp5_ = _tmp4_->next;
2433                 if (_tmp5_ != NULL) {
2434                         GeeTreeSetNode* _tmp6_;
2435                         GeeTreeSetNode* _tmp7_;
2436                         _tmp6_ = self->priv->current;
2437                         _tmp7_ = _tmp6_->next;
2438                         self->priv->current = _tmp7_;
2439                         result = TRUE;
2440                         return result;
2441                 } else {
2442                         result = FALSE;
2443                         return result;
2444                 }
2445         } else {
2446                 gboolean _tmp8_;
2447                 _tmp8_ = self->priv->started;
2448                 if (!_tmp8_) {
2449                         GeeTreeSet* _tmp9_;
2450                         GeeTreeSetNode* _tmp10_;
2451                         GeeTreeSetNode* _tmp11_;
2452                         _tmp9_ = self->priv->_set;
2453                         _tmp10_ = _tmp9_->priv->_first;
2454                         self->priv->current = _tmp10_;
2455                         self->priv->started = TRUE;
2456                         _tmp11_ = self->priv->current;
2457                         result = _tmp11_ != NULL;
2458                         return result;
2459                 } else {
2460                         GeeTreeSetNode* _tmp12_;
2461                         GeeTreeSetNode* _tmp13_;
2462                         GeeTreeSetNode* _tmp14_;
2463                         _tmp12_ = self->priv->_next;
2464                         self->priv->current = _tmp12_;
2465                         _tmp13_ = self->priv->current;
2466                         if (_tmp13_ != NULL) {
2467                                 self->priv->_next = NULL;
2468                                 self->priv->_prev = NULL;
2469                         }
2470                         _tmp14_ = self->priv->current;
2471                         result = _tmp14_ != NULL;
2472                         return result;
2473                 }
2474         }
2475 }
2476
2477
2478 static gboolean gee_tree_set_iterator_real_has_next (GeeIterator* base) {
2479         GeeTreeSetIterator * self;
2480         gboolean result = FALSE;
2481         gint _tmp0_;
2482         GeeTreeSet* _tmp1_;
2483         gint _tmp2_;
2484         gboolean _tmp3_ = FALSE;
2485         gboolean _tmp4_ = FALSE;
2486         gboolean _tmp5_ = FALSE;
2487         gboolean _tmp6_;
2488         gboolean _tmp9_;
2489         gboolean _tmp14_;
2490         gboolean _tmp20_;
2491         self = (GeeTreeSetIterator*) base;
2492         _tmp0_ = self->priv->stamp;
2493         _tmp1_ = self->priv->_set;
2494         _tmp2_ = _tmp1_->priv->stamp;
2495         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2496         _tmp6_ = self->priv->started;
2497         if (!_tmp6_) {
2498                 GeeTreeSet* _tmp7_;
2499                 GeeTreeSetNode* _tmp8_;
2500                 _tmp7_ = self->priv->_set;
2501                 _tmp8_ = _tmp7_->priv->_first;
2502                 _tmp5_ = _tmp8_ != NULL;
2503         } else {
2504                 _tmp5_ = FALSE;
2505         }
2506         _tmp9_ = _tmp5_;
2507         if (_tmp9_) {
2508                 _tmp4_ = TRUE;
2509         } else {
2510                 gboolean _tmp10_ = FALSE;
2511                 GeeTreeSetNode* _tmp11_;
2512                 gboolean _tmp13_;
2513                 _tmp11_ = self->priv->current;
2514                 if (_tmp11_ == NULL) {
2515                         GeeTreeSetNode* _tmp12_;
2516                         _tmp12_ = self->priv->_next;
2517                         _tmp10_ = _tmp12_ != NULL;
2518                 } else {
2519                         _tmp10_ = FALSE;
2520                 }
2521                 _tmp13_ = _tmp10_;
2522                 _tmp4_ = _tmp13_;
2523         }
2524         _tmp14_ = _tmp4_;
2525         if (_tmp14_) {
2526                 _tmp3_ = TRUE;
2527         } else {
2528                 gboolean _tmp15_ = FALSE;
2529                 GeeTreeSetNode* _tmp16_;
2530                 gboolean _tmp19_;
2531                 _tmp16_ = self->priv->current;
2532                 if (_tmp16_ != NULL) {
2533                         GeeTreeSetNode* _tmp17_;
2534                         GeeTreeSetNode* _tmp18_;
2535                         _tmp17_ = self->priv->current;
2536                         _tmp18_ = _tmp17_->next;
2537                         _tmp15_ = _tmp18_ != NULL;
2538                 } else {
2539                         _tmp15_ = FALSE;
2540                 }
2541                 _tmp19_ = _tmp15_;
2542                 _tmp3_ = _tmp19_;
2543         }
2544         _tmp20_ = _tmp3_;
2545         result = _tmp20_;
2546         return result;
2547 }
2548
2549
2550 static gboolean gee_tree_set_iterator_real_first (GeeIterator* base) {
2551         GeeTreeSetIterator * self;
2552         gboolean result = FALSE;
2553         gint _tmp0_;
2554         GeeTreeSet* _tmp1_;
2555         gint _tmp2_;
2556         GeeTreeSet* _tmp3_;
2557         GeeTreeSetNode* _tmp4_;
2558         GeeTreeSetNode* _tmp5_;
2559         self = (GeeTreeSetIterator*) base;
2560         _tmp0_ = self->priv->stamp;
2561         _tmp1_ = self->priv->_set;
2562         _tmp2_ = _tmp1_->priv->stamp;
2563         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2564         _tmp3_ = self->priv->_set;
2565         _tmp4_ = _tmp3_->priv->_first;
2566         self->priv->current = _tmp4_;
2567         self->priv->_next = NULL;
2568         self->priv->_prev = NULL;
2569         self->priv->started = TRUE;
2570         _tmp5_ = self->priv->current;
2571         result = _tmp5_ != NULL;
2572         return result;
2573 }
2574
2575
2576 static gboolean gee_tree_set_iterator_real_previous (GeeBidirIterator* base) {
2577         GeeTreeSetIterator * self;
2578         gboolean result = FALSE;
2579         gint _tmp0_;
2580         GeeTreeSet* _tmp1_;
2581         gint _tmp2_;
2582         GeeTreeSetNode* _tmp3_;
2583         self = (GeeTreeSetIterator*) base;
2584         _tmp0_ = self->priv->stamp;
2585         _tmp1_ = self->priv->_set;
2586         _tmp2_ = _tmp1_->priv->stamp;
2587         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2588         _tmp3_ = self->priv->current;
2589         if (_tmp3_ != NULL) {
2590                 GeeTreeSetNode* _tmp4_;
2591                 GeeTreeSetNode* _tmp5_;
2592                 _tmp4_ = self->priv->current;
2593                 _tmp5_ = _tmp4_->prev;
2594                 if (_tmp5_ != NULL) {
2595                         GeeTreeSetNode* _tmp6_;
2596                         GeeTreeSetNode* _tmp7_;
2597                         _tmp6_ = self->priv->current;
2598                         _tmp7_ = _tmp6_->prev;
2599                         self->priv->current = _tmp7_;
2600                         result = TRUE;
2601                         return result;
2602                 } else {
2603                         result = FALSE;
2604                         return result;
2605                 }
2606         } else {
2607                 GeeTreeSetNode* _tmp8_;
2608                 _tmp8_ = self->priv->_prev;
2609                 if (_tmp8_ != NULL) {
2610                         GeeTreeSetNode* _tmp9_;
2611                         _tmp9_ = self->priv->_prev;
2612                         self->priv->current = _tmp9_;
2613                         self->priv->_next = NULL;
2614                         self->priv->_prev = NULL;
2615                         result = TRUE;
2616                         return result;
2617                 } else {
2618                         result = FALSE;
2619                         return result;
2620                 }
2621         }
2622 }
2623
2624
2625 static gboolean gee_tree_set_iterator_real_has_previous (GeeBidirIterator* base) {
2626         GeeTreeSetIterator * self;
2627         gboolean result = FALSE;
2628         gint _tmp0_;
2629         GeeTreeSet* _tmp1_;
2630         gint _tmp2_;
2631         gboolean _tmp3_ = FALSE;
2632         gboolean _tmp4_ = FALSE;
2633         GeeTreeSetNode* _tmp5_;
2634         gboolean _tmp7_;
2635         gboolean _tmp13_;
2636         self = (GeeTreeSetIterator*) base;
2637         _tmp0_ = self->priv->stamp;
2638         _tmp1_ = self->priv->_set;
2639         _tmp2_ = _tmp1_->priv->stamp;
2640         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2641         _tmp5_ = self->priv->current;
2642         if (_tmp5_ == NULL) {
2643                 GeeTreeSetNode* _tmp6_;
2644                 _tmp6_ = self->priv->_prev;
2645                 _tmp4_ = _tmp6_ != NULL;
2646         } else {
2647                 _tmp4_ = FALSE;
2648         }
2649         _tmp7_ = _tmp4_;
2650         if (_tmp7_) {
2651                 _tmp3_ = TRUE;
2652         } else {
2653                 gboolean _tmp8_ = FALSE;
2654                 GeeTreeSetNode* _tmp9_;
2655                 gboolean _tmp12_;
2656                 _tmp9_ = self->priv->current;
2657                 if (_tmp9_ != NULL) {
2658                         GeeTreeSetNode* _tmp10_;
2659                         GeeTreeSetNode* _tmp11_;
2660                         _tmp10_ = self->priv->current;
2661                         _tmp11_ = _tmp10_->prev;
2662                         _tmp8_ = _tmp11_ != NULL;
2663                 } else {
2664                         _tmp8_ = FALSE;
2665                 }
2666                 _tmp12_ = _tmp8_;
2667                 _tmp3_ = _tmp12_;
2668         }
2669         _tmp13_ = _tmp3_;
2670         result = _tmp13_;
2671         return result;
2672 }
2673
2674
2675 static gboolean gee_tree_set_iterator_real_last (GeeBidirIterator* base) {
2676         GeeTreeSetIterator * self;
2677         gboolean result = FALSE;
2678         gint _tmp0_;
2679         GeeTreeSet* _tmp1_;
2680         gint _tmp2_;
2681         GeeTreeSet* _tmp3_;
2682         GeeTreeSetNode* _tmp4_;
2683         GeeTreeSetNode* _tmp5_;
2684         self = (GeeTreeSetIterator*) base;
2685         _tmp0_ = self->priv->stamp;
2686         _tmp1_ = self->priv->_set;
2687         _tmp2_ = _tmp1_->priv->stamp;
2688         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2689         _tmp3_ = self->priv->_set;
2690         _tmp4_ = _tmp3_->priv->_last;
2691         self->priv->current = _tmp4_;
2692         self->priv->_next = NULL;
2693         self->priv->_prev = NULL;
2694         self->priv->started = TRUE;
2695         _tmp5_ = self->priv->current;
2696         result = _tmp5_ != NULL;
2697         return result;
2698 }
2699
2700
2701 static gpointer gee_tree_set_iterator_real_get (GeeIterator* base) {
2702         GeeTreeSetIterator * self;
2703         gpointer result = NULL;
2704         gint _tmp0_;
2705         GeeTreeSet* _tmp1_;
2706         gint _tmp2_;
2707         GeeTreeSetNode* _tmp3_;
2708         GeeTreeSetNode* _tmp4_;
2709         gconstpointer _tmp5_;
2710         gpointer _tmp6_;
2711         self = (GeeTreeSetIterator*) base;
2712         _tmp0_ = self->priv->stamp;
2713         _tmp1_ = self->priv->_set;
2714         _tmp2_ = _tmp1_->priv->stamp;
2715         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2716         _tmp3_ = self->priv->current;
2717         _vala_assert (_tmp3_ != NULL, "current != null");
2718         _tmp4_ = self->priv->current;
2719         _tmp5_ = _tmp4_->key;
2720         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
2721         result = _tmp6_;
2722         return result;
2723 }
2724
2725
2726 static void gee_tree_set_iterator_real_remove (GeeIterator* base) {
2727         GeeTreeSetIterator * self;
2728         gint _tmp0_;
2729         GeeTreeSet* _tmp1_;
2730         gint _tmp2_;
2731         GeeTreeSetNode* _tmp3_;
2732         GeeTreeSet* _tmp4_;
2733         GeeTreeSet* _tmp5_;
2734         GeeTreeSetNode* _tmp6_;
2735         gconstpointer _tmp7_;
2736         GeeTreeSetNode* _tmp8_ = NULL;
2737         GeeTreeSetNode* _tmp9_ = NULL;
2738         gboolean _tmp10_ = FALSE;
2739         gboolean success;
2740         gboolean _tmp11_;
2741         GeeTreeSet* _tmp12_;
2742         GeeTreeSetNode* _tmp13_;
2743         gint _tmp16_;
2744         GeeTreeSet* _tmp17_;
2745         gint _tmp18_;
2746         self = (GeeTreeSetIterator*) base;
2747         _tmp0_ = self->priv->stamp;
2748         _tmp1_ = self->priv->_set;
2749         _tmp2_ = _tmp1_->priv->stamp;
2750         _vala_assert (_tmp0_ == _tmp2_, "stamp == _set.stamp");
2751         _tmp3_ = self->priv->current;
2752         _vala_assert (_tmp3_ != NULL, "current != null");
2753         _tmp4_ = self->priv->_set;
2754         _tmp5_ = self->priv->_set;
2755         _tmp6_ = self->priv->current;
2756         _tmp7_ = _tmp6_->key;
2757         _tmp10_ = gee_tree_set_remove_from_node (_tmp4_, &_tmp5_->priv->root, _tmp7_, &_tmp8_, &_tmp9_);
2758         self->priv->_prev = _tmp8_;
2759         self->priv->_next = _tmp9_;
2760         success = _tmp10_;
2761         _tmp11_ = success;
2762         _vala_assert (_tmp11_, "success");
2763         _tmp12_ = self->priv->_set;
2764         _tmp13_ = _tmp12_->priv->root;
2765         if (_tmp13_ != NULL) {
2766                 GeeTreeSet* _tmp14_;
2767                 GeeTreeSetNode* _tmp15_;
2768                 _tmp14_ = self->priv->_set;
2769                 _tmp15_ = _tmp14_->priv->root;
2770                 _tmp15_->color = GEE_TREE_SET_NODE_COLOR_BLACK;
2771         }
2772         self->priv->current = NULL;
2773         _tmp16_ = self->priv->stamp;
2774         self->priv->stamp = _tmp16_ + 1;
2775         _tmp17_ = self->priv->_set;
2776         _tmp18_ = _tmp17_->priv->stamp;
2777         _tmp17_->priv->stamp = _tmp18_ + 1;
2778         _vala_assert (_tmp16_ == _tmp18_, "stamp++ == _set.stamp++");
2779 }
2780
2781
2782 static gboolean gee_tree_set_iterator_safe_next_get (GeeTreeSetIterator* self, gpointer* val) {
2783         gpointer _vala_val = NULL;
2784         gboolean result = FALSE;
2785         GeeTreeSetNode* _tmp0_;
2786         g_return_val_if_fail (self != NULL, FALSE);
2787         _tmp0_ = self->priv->current;
2788         if (_tmp0_ != NULL) {
2789                 GeeTreeSet* _tmp1_;
2790                 GeeTreeSetNode* _tmp2_;
2791                 GeeTreeSetNode* _tmp3_;
2792                 gpointer _tmp4_ = NULL;
2793                 GeeTreeSetNode* _tmp5_;
2794                 GeeTreeSetNode* _tmp6_;
2795                 _tmp1_ = self->priv->_set;
2796                 _tmp2_ = self->priv->current;
2797                 _tmp3_ = _tmp2_->next;
2798                 _tmp4_ = gee_tree_set_lift_null_get (_tmp1_, _tmp3_);
2799                 ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2800                 _vala_val = _tmp4_;
2801                 _tmp5_ = self->priv->current;
2802                 _tmp6_ = _tmp5_->next;
2803                 result = _tmp6_ != NULL;
2804                 if (val) {
2805                         *val = _vala_val;
2806                 } else {
2807                         ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2808                 }
2809                 return result;
2810         } else {
2811                 GeeTreeSet* _tmp7_;
2812                 GeeTreeSetNode* _tmp8_;
2813                 gpointer _tmp9_ = NULL;
2814                 GeeTreeSetNode* _tmp10_;
2815                 _tmp7_ = self->priv->_set;
2816                 _tmp8_ = self->priv->_next;
2817                 _tmp9_ = gee_tree_set_lift_null_get (_tmp7_, _tmp8_);
2818                 ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2819                 _vala_val = _tmp9_;
2820                 _tmp10_ = self->priv->_next;
2821                 result = _tmp10_ != NULL;
2822                 if (val) {
2823                         *val = _vala_val;
2824                 } else {
2825                         ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2826                 }
2827                 return result;
2828         }
2829         if (val) {
2830                 *val = _vala_val;
2831         } else {
2832                 ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2833         }
2834 }
2835
2836
2837 static gboolean gee_tree_set_iterator_safe_previous_get (GeeTreeSetIterator* self, gpointer* val) {
2838         gpointer _vala_val = NULL;
2839         gboolean result = FALSE;
2840         GeeTreeSetNode* _tmp0_;
2841         g_return_val_if_fail (self != NULL, FALSE);
2842         _tmp0_ = self->priv->current;
2843         if (_tmp0_ != NULL) {
2844                 GeeTreeSet* _tmp1_;
2845                 GeeTreeSetNode* _tmp2_;
2846                 GeeTreeSetNode* _tmp3_;
2847                 gpointer _tmp4_ = NULL;
2848                 GeeTreeSetNode* _tmp5_;
2849                 GeeTreeSetNode* _tmp6_;
2850                 _tmp1_ = self->priv->_set;
2851                 _tmp2_ = self->priv->current;
2852                 _tmp3_ = _tmp2_->prev;
2853                 _tmp4_ = gee_tree_set_lift_null_get (_tmp1_, _tmp3_);
2854                 ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2855                 _vala_val = _tmp4_;
2856                 _tmp5_ = self->priv->current;
2857                 _tmp6_ = _tmp5_->prev;
2858                 result = _tmp6_ != NULL;
2859                 if (val) {
2860                         *val = _vala_val;
2861                 } else {
2862                         ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2863                 }
2864                 return result;
2865         } else {
2866                 GeeTreeSet* _tmp7_;
2867                 GeeTreeSetNode* _tmp8_;
2868                 gpointer _tmp9_ = NULL;
2869                 GeeTreeSetNode* _tmp10_;
2870                 _tmp7_ = self->priv->_set;
2871                 _tmp8_ = self->priv->_prev;
2872                 _tmp9_ = gee_tree_set_lift_null_get (_tmp7_, _tmp8_);
2873                 ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2874                 _vala_val = _tmp9_;
2875                 _tmp10_ = self->priv->_next;
2876                 result = _tmp10_ != NULL;
2877                 if (val) {
2878                         *val = _vala_val;
2879                 } else {
2880                         ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2881                 }
2882                 return result;
2883         }
2884         if (val) {
2885                 *val = _vala_val;
2886         } else {
2887                 ((_vala_val == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_vala_val = (self->priv->g_destroy_func (_vala_val), NULL));
2888         }
2889 }
2890
2891
2892 static void gee_tree_set_iterator_class_init (GeeTreeSetIteratorClass * klass) {
2893         gee_tree_set_iterator_parent_class = g_type_class_peek_parent (klass);
2894         g_type_class_add_private (klass, sizeof (GeeTreeSetIteratorPrivate));
2895         G_OBJECT_CLASS (klass)->get_property = _vala_gee_tree_set_iterator_get_property;
2896         G_OBJECT_CLASS (klass)->set_property = _vala_gee_tree_set_iterator_set_property;
2897         G_OBJECT_CLASS (klass)->finalize = gee_tree_set_iterator_finalize;
2898         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_ITERATOR_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2899         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_ITERATOR_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2900         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_ITERATOR_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2901 }
2902
2903
2904 static void gee_tree_set_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
2905         gee_tree_set_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
2906         iface->next = (gboolean (*)(GeeIterator*)) gee_tree_set_iterator_real_next;
2907         iface->has_next = (gboolean (*)(GeeIterator*)) gee_tree_set_iterator_real_has_next;
2908         iface->first = (gboolean (*)(GeeIterator*)) gee_tree_set_iterator_real_first;
2909         iface->get = (gpointer (*)(GeeIterator*)) gee_tree_set_iterator_real_get;
2910         iface->remove = (void (*)(GeeIterator*)) gee_tree_set_iterator_real_remove;
2911 }
2912
2913
2914 static void gee_tree_set_iterator_gee_bidir_iterator_interface_init (GeeBidirIteratorIface * iface) {
2915         gee_tree_set_iterator_gee_bidir_iterator_parent_iface = g_type_interface_peek_parent (iface);
2916         iface->previous = (gboolean (*)(GeeBidirIterator*)) gee_tree_set_iterator_real_previous;
2917         iface->has_previous = (gboolean (*)(GeeBidirIterator*)) gee_tree_set_iterator_real_has_previous;
2918         iface->last = (gboolean (*)(GeeBidirIterator*)) gee_tree_set_iterator_real_last;
2919 }
2920
2921
2922 static void gee_tree_set_iterator_instance_init (GeeTreeSetIterator * self) {
2923         self->priv = GEE_TREE_SET_ITERATOR_GET_PRIVATE (self);
2924         self->priv->current = NULL;
2925         self->priv->_next = NULL;
2926         self->priv->_prev = NULL;
2927         self->priv->started = FALSE;
2928 }
2929
2930
2931 static void gee_tree_set_iterator_finalize (GObject* obj) {
2932         GeeTreeSetIterator * self;
2933         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TREE_SET_TYPE_ITERATOR, GeeTreeSetIterator);
2934         _g_object_unref0 (self->priv->_set);
2935         G_OBJECT_CLASS (gee_tree_set_iterator_parent_class)->finalize (obj);
2936 }
2937
2938
2939 static GType gee_tree_set_iterator_get_type (void) {
2940         static volatile gsize gee_tree_set_iterator_type_id__volatile = 0;
2941         if (g_once_init_enter (&gee_tree_set_iterator_type_id__volatile)) {
2942                 static const GTypeInfo g_define_type_info = { sizeof (GeeTreeSetIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_tree_set_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeTreeSetIterator), 0, (GInstanceInitFunc) gee_tree_set_iterator_instance_init, NULL };
2943                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_tree_set_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2944                 static const GInterfaceInfo gee_bidir_iterator_info = { (GInterfaceInitFunc) gee_tree_set_iterator_gee_bidir_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2945                 GType gee_tree_set_iterator_type_id;
2946                 gee_tree_set_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeTreeSetIterator", &g_define_type_info, 0);
2947                 g_type_add_interface_static (gee_tree_set_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
2948                 g_type_add_interface_static (gee_tree_set_iterator_type_id, GEE_TYPE_BIDIR_ITERATOR, &gee_bidir_iterator_info);
2949                 g_once_init_leave (&gee_tree_set_iterator_type_id__volatile, gee_tree_set_iterator_type_id);
2950         }
2951         return gee_tree_set_iterator_type_id__volatile;
2952 }
2953
2954
2955 static void _vala_gee_tree_set_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2956         GeeTreeSetIterator * self;
2957         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TREE_SET_TYPE_ITERATOR, GeeTreeSetIterator);
2958         switch (property_id) {
2959                 default:
2960                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2961                 break;
2962         }
2963 }
2964
2965
2966 static void _vala_gee_tree_set_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2967         GeeTreeSetIterator * self;
2968         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TREE_SET_TYPE_ITERATOR, GeeTreeSetIterator);
2969         switch (property_id) {
2970                 case GEE_TREE_SET_ITERATOR_G_TYPE:
2971                 self->priv->g_type = g_value_get_gtype (value);
2972                 break;
2973                 case GEE_TREE_SET_ITERATOR_G_DUP_FUNC:
2974                 self->priv->g_dup_func = g_value_get_pointer (value);
2975                 break;
2976                 case GEE_TREE_SET_ITERATOR_G_DESTROY_FUNC:
2977                 self->priv->g_destroy_func = g_value_get_pointer (value);
2978                 break;
2979                 default:
2980                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2981                 break;
2982         }
2983 }
2984
2985
2986 static GeeTreeSetRange* gee_tree_set_range_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before) {
2987         GeeTreeSetRange* self = NULL;
2988         GeeTreeSet* _tmp0_;
2989         GeeTreeSet* _tmp1_;
2990         GeeTreeSet* _tmp2_;
2991         GCompareFunc _tmp3_;
2992         GCompareFunc _tmp4_;
2993         gconstpointer _tmp5_;
2994         gconstpointer _tmp6_;
2995         gint _tmp7_ = 0;
2996         g_return_val_if_fail (set != NULL, NULL);
2997         self = (GeeTreeSetRange*) g_type_create_instance (object_type);
2998         self->priv->g_type = g_type;
2999         self->priv->g_dup_func = g_dup_func;
3000         self->priv->g_destroy_func = g_destroy_func;
3001         _tmp0_ = set;
3002         _tmp1_ = _g_object_ref0 (_tmp0_);
3003         _g_object_unref0 (self->priv->set);
3004         self->priv->set = _tmp1_;
3005         _tmp2_ = set;
3006         _tmp3_ = gee_tree_set_get_compare_func (_tmp2_);
3007         _tmp4_ = _tmp3_;
3008         _tmp5_ = after;
3009         _tmp6_ = before;
3010         _tmp7_ = _tmp4_ (_tmp5_, _tmp6_);
3011         if (_tmp7_ < 0) {
3012                 gconstpointer _tmp8_;
3013                 gpointer _tmp9_;
3014                 gconstpointer _tmp10_;
3015                 gpointer _tmp11_;
3016                 _tmp8_ = after;
3017                 _tmp9_ = ((_tmp8_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
3018                 _g_destroy_func0 (self->priv->after);
3019                 self->priv->after = _tmp9_;
3020                 _tmp10_ = before;
3021                 _tmp11_ = ((_tmp10_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp10_) : ((gpointer) _tmp10_);
3022                 _g_destroy_func0 (self->priv->before);
3023                 self->priv->before = _tmp11_;
3024                 self->priv->type = GEE_TREE_SET_RANGE_TYPE_BOUNDED;
3025         } else {
3026                 self->priv->type = GEE_TREE_SET_RANGE_TYPE_EMPTY;
3027         }
3028         return self;
3029 }
3030
3031
3032 static GeeTreeSetRange* gee_tree_set_range_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before) {
3033         return gee_tree_set_range_construct (GEE_TREE_SET_TYPE_RANGE, g_type, g_dup_func, g_destroy_func, set, after, before);
3034 }
3035
3036
3037 static GeeTreeSetRange* gee_tree_set_range_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before) {
3038         GeeTreeSetRange* self = NULL;
3039         GeeTreeSet* _tmp0_;
3040         GeeTreeSet* _tmp1_;
3041         gconstpointer _tmp2_;
3042         gpointer _tmp3_;
3043         g_return_val_if_fail (set != NULL, NULL);
3044         self = (GeeTreeSetRange*) g_type_create_instance (object_type);
3045         self->priv->g_type = g_type;
3046         self->priv->g_dup_func = g_dup_func;
3047         self->priv->g_destroy_func = g_destroy_func;
3048         _tmp0_ = set;
3049         _tmp1_ = _g_object_ref0 (_tmp0_);
3050         _g_object_unref0 (self->priv->set);
3051         self->priv->set = _tmp1_;
3052         _tmp2_ = before;
3053         _tmp3_ = ((_tmp2_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
3054         _g_destroy_func0 (self->priv->before);
3055         self->priv->before = _tmp3_;
3056         self->priv->type = GEE_TREE_SET_RANGE_TYPE_HEAD;
3057         return self;
3058 }
3059
3060
3061 static GeeTreeSetRange* gee_tree_set_range_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before) {
3062         return gee_tree_set_range_construct_head (GEE_TREE_SET_TYPE_RANGE, g_type, g_dup_func, g_destroy_func, set, before);
3063 }
3064
3065
3066 static GeeTreeSetRange* gee_tree_set_range_construct_tail (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after) {
3067         GeeTreeSetRange* self = NULL;
3068         GeeTreeSet* _tmp0_;
3069         GeeTreeSet* _tmp1_;
3070         gconstpointer _tmp2_;
3071         gpointer _tmp3_;
3072         g_return_val_if_fail (set != NULL, NULL);
3073         self = (GeeTreeSetRange*) g_type_create_instance (object_type);
3074         self->priv->g_type = g_type;
3075         self->priv->g_dup_func = g_dup_func;
3076         self->priv->g_destroy_func = g_destroy_func;
3077         _tmp0_ = set;
3078         _tmp1_ = _g_object_ref0 (_tmp0_);
3079         _g_object_unref0 (self->priv->set);
3080         self->priv->set = _tmp1_;
3081         _tmp2_ = after;
3082         _tmp3_ = ((_tmp2_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
3083         _g_destroy_func0 (self->priv->after);
3084         self->priv->after = _tmp3_;
3085         self->priv->type = GEE_TREE_SET_RANGE_TYPE_TAIL;
3086         return self;
3087 }
3088
3089
3090 static GeeTreeSetRange* gee_tree_set_range_new_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after) {
3091         return gee_tree_set_range_construct_tail (GEE_TREE_SET_TYPE_RANGE, g_type, g_dup_func, g_destroy_func, set, after);
3092 }
3093
3094
3095 static gpointer _gee_tree_set_range_ref0 (gpointer self) {
3096         return self ? gee_tree_set_range_ref (self) : NULL;
3097 }
3098
3099
3100 static GeeTreeSetRange* gee_tree_set_range_cut_head (GeeTreeSetRange* self, gconstpointer after) {
3101         GeeTreeSetRange* result = NULL;
3102         GeeTreeSetRangeType _tmp0_;
3103         g_return_val_if_fail (self != NULL, NULL);
3104         _tmp0_ = self->priv->type;
3105         switch (_tmp0_) {
3106                 case GEE_TREE_SET_RANGE_TYPE_HEAD:
3107                 {
3108                         GeeTreeSet* _tmp1_;
3109                         gconstpointer _tmp2_;
3110                         gconstpointer _tmp3_;
3111                         GeeTreeSetRange* _tmp4_;
3112                         _tmp1_ = self->priv->set;
3113                         _tmp2_ = after;
3114                         _tmp3_ = self->priv->before;
3115                         _tmp4_ = gee_tree_set_range_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_, _tmp3_);
3116                         result = _tmp4_;
3117                         return result;
3118                 }
3119                 case GEE_TREE_SET_RANGE_TYPE_TAIL:
3120                 {
3121                         GeeTreeSet* _tmp5_;
3122                         GeeTreeSet* _tmp6_;
3123                         gconstpointer _tmp7_;
3124                         gconstpointer _tmp8_;
3125                         gpointer _tmp9_ = NULL;
3126                         gpointer _tmp10_;
3127                         GeeTreeSetRange* _tmp11_;
3128                         GeeTreeSetRange* _tmp12_;
3129                         _tmp5_ = self->priv->set;
3130                         _tmp6_ = self->priv->set;
3131                         _tmp7_ = after;
3132                         _tmp8_ = self->priv->after;
3133                         _tmp9_ = gee_tree_set_max (_tmp6_, _tmp7_, _tmp8_);
3134                         _tmp10_ = _tmp9_;
3135                         _tmp11_ = gee_tree_set_range_new_tail (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp5_, _tmp10_);
3136                         _tmp12_ = _tmp11_;
3137                         ((_tmp10_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp10_ = (self->priv->g_destroy_func (_tmp10_), NULL));
3138                         result = _tmp12_;
3139                         return result;
3140                 }
3141                 case GEE_TREE_SET_RANGE_TYPE_EMPTY:
3142                 {
3143                         GeeTreeSetRange* _tmp13_;
3144                         _tmp13_ = _gee_tree_set_range_ref0 (self);
3145                         result = _tmp13_;
3146                         return result;
3147                 }
3148                 case GEE_TREE_SET_RANGE_TYPE_BOUNDED:
3149                 {
3150                         GeeTreeSet* _tmp14_;
3151                         gconstpointer _tmp15_;
3152                         gconstpointer _tmp16_;
3153                         gpointer _tmp17_ = NULL;
3154                         gpointer _after;
3155                         GeeTreeSet* _tmp18_;
3156                         gconstpointer _tmp19_;
3157                         gconstpointer _tmp20_;
3158                         GeeTreeSetRange* _tmp21_;
3159                         _tmp14_ = self->priv->set;
3160                         _tmp15_ = after;
3161                         _tmp16_ = self->priv->after;
3162                         _tmp17_ = gee_tree_set_max (_tmp14_, _tmp15_, _tmp16_);
3163                         _after = _tmp17_;
3164                         _tmp18_ = self->priv->set;
3165                         _tmp19_ = _after;
3166                         _tmp20_ = self->priv->before;
3167                         _tmp21_ = gee_tree_set_range_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp18_, _tmp19_, _tmp20_);
3168                         result = _tmp21_;
3169                         ((_after == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_after = (self->priv->g_destroy_func (_after), NULL));
3170                         return result;
3171                 }
3172                 default:
3173                 {
3174                         g_assert_not_reached ();
3175                 }
3176         }
3177 }
3178
3179
3180 static GeeTreeSetRange* gee_tree_set_range_cut_tail (GeeTreeSetRange* self, gconstpointer before) {
3181         GeeTreeSetRange* result = NULL;
3182         GeeTreeSetRangeType _tmp0_;
3183         g_return_val_if_fail (self != NULL, NULL);
3184         _tmp0_ = self->priv->type;
3185         switch (_tmp0_) {
3186                 case GEE_TREE_SET_RANGE_TYPE_HEAD:
3187                 {
3188                         GeeTreeSet* _tmp1_;
3189                         GeeTreeSet* _tmp2_;
3190                         gconstpointer _tmp3_;
3191                         gconstpointer _tmp4_;
3192                         gpointer _tmp5_ = NULL;
3193                         gpointer _tmp6_;
3194                         GeeTreeSetRange* _tmp7_;
3195                         GeeTreeSetRange* _tmp8_;
3196                         _tmp1_ = self->priv->set;
3197                         _tmp2_ = self->priv->set;
3198                         _tmp3_ = before;
3199                         _tmp4_ = self->priv->before;
3200                         _tmp5_ = gee_tree_set_min (_tmp2_, _tmp3_, _tmp4_);
3201                         _tmp6_ = _tmp5_;
3202                         _tmp7_ = gee_tree_set_range_new_head (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp6_);
3203                         _tmp8_ = _tmp7_;
3204                         ((_tmp6_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp6_ = (self->priv->g_destroy_func (_tmp6_), NULL));
3205                         result = _tmp8_;
3206                         return result;
3207                 }
3208                 case GEE_TREE_SET_RANGE_TYPE_TAIL:
3209                 {
3210                         GeeTreeSet* _tmp9_;
3211                         gconstpointer _tmp10_;
3212                         gconstpointer _tmp11_;
3213                         GeeTreeSetRange* _tmp12_;
3214                         _tmp9_ = self->priv->set;
3215                         _tmp10_ = self->priv->after;
3216                         _tmp11_ = before;
3217                         _tmp12_ = gee_tree_set_range_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp9_, _tmp10_, _tmp11_);
3218                         result = _tmp12_;
3219                         return result;
3220                 }
3221                 case GEE_TREE_SET_RANGE_TYPE_EMPTY:
3222                 {
3223                         GeeTreeSetRange* _tmp13_;
3224                         _tmp13_ = _gee_tree_set_range_ref0 (self);
3225                         result = _tmp13_;
3226                         return result;
3227                 }
3228                 case GEE_TREE_SET_RANGE_TYPE_BOUNDED:
3229                 {
3230                         GeeTreeSet* _tmp14_;
3231                         gconstpointer _tmp15_;
3232                         gconstpointer _tmp16_;
3233                         gpointer _tmp17_ = NULL;
3234                         gpointer _before;
3235                         GeeTreeSet* _tmp18_;
3236                         gconstpointer _tmp19_;
3237                         gconstpointer _tmp20_;
3238                         GeeTreeSetRange* _tmp21_;
3239                         _tmp14_ = self->priv->set;
3240                         _tmp15_ = before;
3241                         _tmp16_ = self->priv->before;
3242                         _tmp17_ = gee_tree_set_min (_tmp14_, _tmp15_, _tmp16_);
3243                         _before = _tmp17_;
3244                         _tmp18_ = self->priv->set;
3245                         _tmp19_ = self->priv->after;
3246                         _tmp20_ = _before;
3247                         _tmp21_ = gee_tree_set_range_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp18_, _tmp19_, _tmp20_);
3248                         result = _tmp21_;
3249                         ((_before == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_before = (self->priv->g_destroy_func (_before), NULL));
3250                         return result;
3251                 }
3252                 default:
3253                 {
3254                         g_assert_not_reached ();
3255                 }
3256         }
3257 }
3258
3259
3260 static GeeTreeSetRange* gee_tree_set_range_cut (GeeTreeSetRange* self, gconstpointer after, gconstpointer before) {
3261         GeeTreeSetRange* result = NULL;
3262         GeeTreeSetRangeType _tmp0_;
3263         gpointer _tmp2_ = NULL;
3264         GeeTreeSetRangeType _tmp3_;
3265         gconstpointer _tmp10_;
3266         gpointer _tmp11_;
3267         gpointer _before;
3268         gpointer _tmp12_ = NULL;
3269         GeeTreeSetRangeType _tmp13_;
3270         gconstpointer _tmp20_;
3271         gpointer _tmp21_;
3272         gpointer _after;
3273         GeeTreeSet* _tmp22_;
3274         gconstpointer _tmp23_;
3275         gconstpointer _tmp24_;
3276         GeeTreeSetRange* _tmp25_;
3277         g_return_val_if_fail (self != NULL, NULL);
3278         _tmp0_ = self->priv->type;
3279         if (_tmp0_ == GEE_TREE_SET_RANGE_TYPE_EMPTY) {
3280                 GeeTreeSetRange* _tmp1_;
3281                 _tmp1_ = _gee_tree_set_range_ref0 (self);
3282                 result = _tmp1_;
3283                 return result;
3284         }
3285         _tmp3_ = self->priv->type;
3286         if (_tmp3_ != GEE_TREE_SET_RANGE_TYPE_TAIL) {
3287                 GeeTreeSet* _tmp4_;
3288                 gconstpointer _tmp5_;
3289                 gconstpointer _tmp6_;
3290                 gpointer _tmp7_ = NULL;
3291                 _tmp4_ = self->priv->set;
3292                 _tmp5_ = before;
3293                 _tmp6_ = self->priv->before;
3294                 _tmp7_ = gee_tree_set_min (_tmp4_, _tmp5_, _tmp6_);
3295                 ((_tmp2_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp2_ = (self->priv->g_destroy_func (_tmp2_), NULL));
3296                 _tmp2_ = _tmp7_;
3297         } else {
3298                 gconstpointer _tmp8_;
3299                 gpointer _tmp9_;
3300                 _tmp8_ = before;
3301                 _tmp9_ = ((_tmp8_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
3302                 ((_tmp2_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp2_ = (self->priv->g_destroy_func (_tmp2_), NULL));
3303                 _tmp2_ = _tmp9_;
3304         }
3305         _tmp10_ = _tmp2_;
3306         _tmp11_ = ((_tmp10_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp10_) : ((gpointer) _tmp10_);
3307         _before = _tmp11_;
3308         _tmp13_ = self->priv->type;
3309         if (_tmp13_ != GEE_TREE_SET_RANGE_TYPE_HEAD) {
3310                 GeeTreeSet* _tmp14_;
3311                 gconstpointer _tmp15_;
3312                 gconstpointer _tmp16_;
3313                 gpointer _tmp17_ = NULL;
3314                 _tmp14_ = self->priv->set;
3315                 _tmp15_ = after;
3316                 _tmp16_ = self->priv->after;
3317                 _tmp17_ = gee_tree_set_max (_tmp14_, _tmp15_, _tmp16_);
3318                 ((_tmp12_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp12_ = (self->priv->g_destroy_func (_tmp12_), NULL));
3319                 _tmp12_ = _tmp17_;
3320         } else {
3321                 gconstpointer _tmp18_;
3322                 gpointer _tmp19_;
3323                 _tmp18_ = after;
3324                 _tmp19_ = ((_tmp18_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp18_) : ((gpointer) _tmp18_);
3325                 ((_tmp12_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp12_ = (self->priv->g_destroy_func (_tmp12_), NULL));
3326                 _tmp12_ = _tmp19_;
3327         }
3328         _tmp20_ = _tmp12_;
3329         _tmp21_ = ((_tmp20_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp20_) : ((gpointer) _tmp20_);
3330         _after = _tmp21_;
3331         _tmp22_ = self->priv->set;
3332         _tmp23_ = _after;
3333         _tmp24_ = _before;
3334         _tmp25_ = gee_tree_set_range_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp22_, _tmp23_, _tmp24_);
3335         result = _tmp25_;
3336         ((_after == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_after = (self->priv->g_destroy_func (_after), NULL));
3337         ((_tmp12_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp12_ = (self->priv->g_destroy_func (_tmp12_), NULL));
3338         ((_before == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_before = (self->priv->g_destroy_func (_before), NULL));
3339         ((_tmp2_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp2_ = (self->priv->g_destroy_func (_tmp2_), NULL));
3340         return result;
3341 }
3342
3343
3344 static gboolean gee_tree_set_range_in_range (GeeTreeSetRange* self, gconstpointer item) {
3345         gboolean result = FALSE;
3346         gboolean _tmp0_ = FALSE;
3347         GeeTreeSetRangeType _tmp1_;
3348         gboolean _tmp4_;
3349         g_return_val_if_fail (self != NULL, FALSE);
3350         _tmp1_ = self->priv->type;
3351         if (_tmp1_ == GEE_TREE_SET_RANGE_TYPE_EMPTY) {
3352                 _tmp0_ = FALSE;
3353         } else {
3354                 gconstpointer _tmp2_;
3355                 gint _tmp3_ = 0;
3356                 _tmp2_ = item;
3357                 _tmp3_ = gee_tree_set_range_compare_range (self, _tmp2_);
3358                 _tmp0_ = _tmp3_ == 0;
3359         }
3360         _tmp4_ = _tmp0_;
3361         result = _tmp4_;
3362         return result;
3363 }
3364
3365
3366 static gint gee_tree_set_range_compare_range (GeeTreeSetRange* self, gconstpointer item) {
3367         gint result = 0;
3368         GeeTreeSetRangeType _tmp0_;
3369         g_return_val_if_fail (self != NULL, 0);
3370         _tmp0_ = self->priv->type;
3371         switch (_tmp0_) {
3372                 case GEE_TREE_SET_RANGE_TYPE_HEAD:
3373                 {
3374                         gint _tmp1_ = 0;
3375                         GeeTreeSet* _tmp2_;
3376                         GCompareFunc _tmp3_;
3377                         GCompareFunc _tmp4_;
3378                         gconstpointer _tmp5_;
3379                         gconstpointer _tmp6_;
3380                         gint _tmp7_ = 0;
3381                         gint _tmp8_;
3382                         _tmp2_ = self->priv->set;
3383                         _tmp3_ = gee_tree_set_get_compare_func (_tmp2_);
3384                         _tmp4_ = _tmp3_;
3385                         _tmp5_ = item;
3386                         _tmp6_ = self->priv->before;
3387                         _tmp7_ = _tmp4_ (_tmp5_, _tmp6_);
3388                         if (_tmp7_ < 0) {
3389                                 _tmp1_ = 0;
3390                         } else {
3391                                 _tmp1_ = 1;
3392                         }
3393                         _tmp8_ = _tmp1_;
3394                         result = _tmp8_;
3395                         return result;
3396                 }
3397                 case GEE_TREE_SET_RANGE_TYPE_TAIL:
3398                 {
3399                         gint _tmp9_ = 0;
3400                         GeeTreeSet* _tmp10_;
3401                         GCompareFunc _tmp11_;
3402                         GCompareFunc _tmp12_;
3403                         gconstpointer _tmp13_;
3404                         gconstpointer _tmp14_;
3405                         gint _tmp15_ = 0;
3406                         gint _tmp16_;
3407                         _tmp10_ = self->priv->set;
3408                         _tmp11_ = gee_tree_set_get_compare_func (_tmp10_);
3409                         _tmp12_ = _tmp11_;
3410                         _tmp13_ = item;
3411                         _tmp14_ = self->priv->after;
3412                         _tmp15_ = _tmp12_ (_tmp13_, _tmp14_);
3413                         if (_tmp15_ >= 0) {
3414                                 _tmp9_ = 0;
3415                         } else {
3416                                 _tmp9_ = -1;
3417                         }
3418                         _tmp16_ = _tmp9_;
3419                         result = _tmp16_;
3420                         return result;
3421                 }
3422                 case GEE_TREE_SET_RANGE_TYPE_EMPTY:
3423                 {
3424                         result = 0;
3425                         return result;
3426                 }
3427                 case GEE_TREE_SET_RANGE_TYPE_BOUNDED:
3428                 {
3429                         gint _tmp17_ = 0;
3430                         GeeTreeSet* _tmp18_;
3431                         GCompareFunc _tmp19_;
3432                         GCompareFunc _tmp20_;
3433                         gconstpointer _tmp21_;
3434                         gconstpointer _tmp22_;
3435                         gint _tmp23_ = 0;
3436                         gint _tmp32_;
3437                         _tmp18_ = self->priv->set;
3438                         _tmp19_ = gee_tree_set_get_compare_func (_tmp18_);
3439                         _tmp20_ = _tmp19_;
3440                         _tmp21_ = item;
3441                         _tmp22_ = self->priv->after;
3442                         _tmp23_ = _tmp20_ (_tmp21_, _tmp22_);
3443                         if (_tmp23_ >= 0) {
3444                                 gint _tmp24_ = 0;
3445                                 GeeTreeSet* _tmp25_;
3446                                 GCompareFunc _tmp26_;
3447                                 GCompareFunc _tmp27_;
3448                                 gconstpointer _tmp28_;
3449                                 gconstpointer _tmp29_;
3450                                 gint _tmp30_ = 0;
3451                                 gint _tmp31_;
3452                                 _tmp25_ = self->priv->set;
3453                                 _tmp26_ = gee_tree_set_get_compare_func (_tmp25_);
3454                                 _tmp27_ = _tmp26_;
3455                                 _tmp28_ = item;
3456                                 _tmp29_ = self->priv->before;
3457                                 _tmp30_ = _tmp27_ (_tmp28_, _tmp29_);
3458                                 if (_tmp30_ < 0) {
3459                                         _tmp24_ = 0;
3460                                 } else {
3461                                         _tmp24_ = 1;
3462                                 }
3463                                 _tmp31_ = _tmp24_;
3464                                 _tmp17_ = _tmp31_;
3465                         } else {
3466                                 _tmp17_ = -1;
3467                         }
3468                         _tmp32_ = _tmp17_;
3469                         result = _tmp32_;
3470                         return result;
3471                 }
3472                 default:
3473                 {
3474                         g_assert_not_reached ();
3475                 }
3476         }
3477 }
3478
3479
3480 static gboolean gee_tree_set_range_empty_subset (GeeTreeSetRange* self) {
3481         gboolean result = FALSE;
3482         GeeTreeSetRangeType _tmp0_;
3483         g_return_val_if_fail (self != NULL, FALSE);
3484         _tmp0_ = self->priv->type;
3485         switch (_tmp0_) {
3486                 case GEE_TREE_SET_RANGE_TYPE_HEAD:
3487                 {
3488                         gboolean _tmp1_ = FALSE;
3489                         GeeTreeSet* _tmp2_;
3490                         GeeTreeSetNode* _tmp3_;
3491                         gboolean _tmp8_;
3492                         _tmp2_ = self->priv->set;
3493                         _tmp3_ = _tmp2_->priv->_first;
3494                         if (_tmp3_ == NULL) {
3495                                 _tmp1_ = TRUE;
3496                         } else {
3497                                 GeeTreeSet* _tmp4_;
3498                                 GeeTreeSetNode* _tmp5_;
3499                                 gconstpointer _tmp6_;
3500                                 gboolean _tmp7_ = FALSE;
3501                                 _tmp4_ = self->priv->set;
3502                                 _tmp5_ = _tmp4_->priv->_first;
3503                                 _tmp6_ = _tmp5_->key;
3504                                 _tmp7_ = gee_tree_set_range_in_range (self, _tmp6_);
3505                                 _tmp1_ = !_tmp7_;
3506                         }
3507                         _tmp8_ = _tmp1_;
3508                         result = _tmp8_;
3509                         return result;
3510                 }
3511                 case GEE_TREE_SET_RANGE_TYPE_TAIL:
3512                 {
3513                         gboolean _tmp9_ = FALSE;
3514                         GeeTreeSet* _tmp10_;
3515                         GeeTreeSetNode* _tmp11_;
3516                         gboolean _tmp16_;
3517                         _tmp10_ = self->priv->set;
3518                         _tmp11_ = _tmp10_->priv->_last;
3519                         if (_tmp11_ == NULL) {
3520                                 _tmp9_ = TRUE;
3521                         } else {
3522                                 GeeTreeSet* _tmp12_;
3523                                 GeeTreeSetNode* _tmp13_;
3524                                 gconstpointer _tmp14_;
3525                                 gboolean _tmp15_ = FALSE;
3526                                 _tmp12_ = self->priv->set;
3527                                 _tmp13_ = _tmp12_->priv->_last;
3528                                 _tmp14_ = _tmp13_->key;
3529                                 _tmp15_ = gee_tree_set_range_in_range (self, _tmp14_);
3530                                 _tmp9_ = !_tmp15_;
3531                         }
3532                         _tmp16_ = _tmp9_;
3533                         result = _tmp16_;
3534                         return result;
3535                 }
3536                 case GEE_TREE_SET_RANGE_TYPE_EMPTY:
3537                 {
3538                         result = TRUE;
3539                         return result;
3540                 }
3541                 case GEE_TREE_SET_RANGE_TYPE_BOUNDED:
3542                 {
3543                         GeeTreeSetNode* _tmp17_ = NULL;
3544                         _tmp17_ = gee_tree_set_range_first (self);
3545                         result = _tmp17_ == NULL;
3546                         return result;
3547                 }
3548                 default:
3549                 {
3550                         g_assert_not_reached ();
3551                 }
3552         }
3553 }
3554
3555
3556 static GeeTreeSetNode* gee_tree_set_range_first (GeeTreeSetRange* self) {
3557         GeeTreeSetNode* result = NULL;
3558         GeeTreeSetRangeType _tmp0_;
3559         g_return_val_if_fail (self != NULL, NULL);
3560         _tmp0_ = self->priv->type;
3561         switch (_tmp0_) {
3562                 case GEE_TREE_SET_RANGE_TYPE_EMPTY:
3563                 {
3564                         result = NULL;
3565                         return result;
3566                 }
3567                 case GEE_TREE_SET_RANGE_TYPE_HEAD:
3568                 {
3569                         GeeTreeSet* _tmp1_;
3570                         GeeTreeSetNode* _tmp2_;
3571                         _tmp1_ = self->priv->set;
3572                         _tmp2_ = _tmp1_->priv->_first;
3573                         result = _tmp2_;
3574                         return result;
3575                 }
3576                 default:
3577                 {
3578                         GeeTreeSet* _tmp3_;
3579                         gconstpointer _tmp4_;
3580                         GeeTreeSetNode* _tmp5_ = NULL;
3581                         _tmp3_ = self->priv->set;
3582                         _tmp4_ = self->priv->after;
3583                         _tmp5_ = gee_tree_set_find_floor (_tmp3_, _tmp4_);
3584                         result = _tmp5_;
3585                         return result;
3586                 }
3587         }
3588 }
3589
3590
3591 static GeeTreeSetNode* gee_tree_set_range_last (GeeTreeSetRange* self) {
3592         GeeTreeSetNode* result = NULL;
3593         GeeTreeSetRangeType _tmp0_;
3594         g_return_val_if_fail (self != NULL, NULL);
3595         _tmp0_ = self->priv->type;
3596         switch (_tmp0_) {
3597                 case GEE_TREE_SET_RANGE_TYPE_EMPTY:
3598                 {
3599                         result = NULL;
3600                         return result;
3601                 }
3602                 case GEE_TREE_SET_RANGE_TYPE_TAIL:
3603                 {
3604                         GeeTreeSet* _tmp1_;
3605                         GeeTreeSetNode* _tmp2_;
3606                         _tmp1_ = self->priv->set;
3607                         _tmp2_ = _tmp1_->priv->_last;
3608                         result = _tmp2_;
3609                         return result;
3610                 }
3611                 default:
3612                 {
3613                         GeeTreeSet* _tmp3_;
3614                         gconstpointer _tmp4_;
3615                         GeeTreeSetNode* _tmp5_ = NULL;
3616                         _tmp3_ = self->priv->set;
3617                         _tmp4_ = self->priv->before;
3618                         _tmp5_ = gee_tree_set_find_lower (_tmp3_, _tmp4_);
3619                         result = _tmp5_;
3620                         return result;
3621                 }
3622         }
3623 }
3624
3625
3626 static void gee_tree_set_value_range_init (GValue* value) {
3627         value->data[0].v_pointer = NULL;
3628 }
3629
3630
3631 static void gee_tree_set_value_range_free_value (GValue* value) {
3632         if (value->data[0].v_pointer) {
3633                 gee_tree_set_range_unref (value->data[0].v_pointer);
3634         }
3635 }
3636
3637
3638 static void gee_tree_set_value_range_copy_value (const GValue* src_value, GValue* dest_value) {
3639         if (src_value->data[0].v_pointer) {
3640                 dest_value->data[0].v_pointer = gee_tree_set_range_ref (src_value->data[0].v_pointer);
3641         } else {
3642                 dest_value->data[0].v_pointer = NULL;
3643         }
3644 }
3645
3646
3647 static gpointer gee_tree_set_value_range_peek_pointer (const GValue* value) {
3648         return value->data[0].v_pointer;
3649 }
3650
3651
3652 static gchar* gee_tree_set_value_range_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
3653         if (collect_values[0].v_pointer) {
3654                 GeeTreeSetRange* object;
3655                 object = collect_values[0].v_pointer;
3656                 if (object->parent_instance.g_class == NULL) {
3657                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
3658                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
3659                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
3660                 }
3661                 value->data[0].v_pointer = gee_tree_set_range_ref (object);
3662         } else {
3663                 value->data[0].v_pointer = NULL;
3664         }
3665         return NULL;
3666 }
3667
3668
3669 static gchar* gee_tree_set_value_range_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
3670         GeeTreeSetRange** object_p;
3671         object_p = collect_values[0].v_pointer;
3672         if (!object_p) {
3673                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
3674         }
3675         if (!value->data[0].v_pointer) {
3676                 *object_p = NULL;
3677         } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
3678                 *object_p = value->data[0].v_pointer;
3679         } else {
3680                 *object_p = gee_tree_set_range_ref (value->data[0].v_pointer);
3681         }
3682         return NULL;
3683 }
3684
3685
3686 static GParamSpec* gee_tree_set_param_spec_range (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
3687         GeeTreeSetParamSpecRange* spec;
3688         g_return_val_if_fail (g_type_is_a (object_type, GEE_TREE_SET_TYPE_RANGE), NULL);
3689         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
3690         G_PARAM_SPEC (spec)->value_type = object_type;
3691         return G_PARAM_SPEC (spec);
3692 }
3693
3694
3695 static gpointer gee_tree_set_value_get_range (const GValue* value) {
3696         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_TREE_SET_TYPE_RANGE), NULL);
3697         return value->data[0].v_pointer;
3698 }
3699
3700
3701 static void gee_tree_set_value_set_range (GValue* value, gpointer v_object) {
3702         GeeTreeSetRange* old;
3703         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_TREE_SET_TYPE_RANGE));
3704         old = value->data[0].v_pointer;
3705         if (v_object) {
3706                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_TREE_SET_TYPE_RANGE));
3707                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
3708                 value->data[0].v_pointer = v_object;
3709                 gee_tree_set_range_ref (value->data[0].v_pointer);
3710         } else {
3711                 value->data[0].v_pointer = NULL;
3712         }
3713         if (old) {
3714                 gee_tree_set_range_unref (old);
3715         }
3716 }
3717
3718
3719 static void gee_tree_set_value_take_range (GValue* value, gpointer v_object) {
3720         GeeTreeSetRange* old;
3721         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_TREE_SET_TYPE_RANGE));
3722         old = value->data[0].v_pointer;
3723         if (v_object) {
3724                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_TREE_SET_TYPE_RANGE));
3725                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
3726                 value->data[0].v_pointer = v_object;
3727         } else {
3728                 value->data[0].v_pointer = NULL;
3729         }
3730         if (old) {
3731                 gee_tree_set_range_unref (old);
3732         }
3733 }
3734
3735
3736 static void gee_tree_set_range_class_init (GeeTreeSetRangeClass * klass) {
3737         gee_tree_set_range_parent_class = g_type_class_peek_parent (klass);
3738         GEE_TREE_SET_RANGE_CLASS (klass)->finalize = gee_tree_set_range_finalize;
3739         g_type_class_add_private (klass, sizeof (GeeTreeSetRangePrivate));
3740 }
3741
3742
3743 static void gee_tree_set_range_instance_init (GeeTreeSetRange * self) {
3744         self->priv = GEE_TREE_SET_RANGE_GET_PRIVATE (self);
3745         self->ref_count = 1;
3746 }
3747
3748
3749 static void gee_tree_set_range_finalize (GeeTreeSetRange* obj) {
3750         GeeTreeSetRange * self;
3751         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TREE_SET_TYPE_RANGE, GeeTreeSetRange);
3752         _g_object_unref0 (self->priv->set);
3753         ((self->priv->after == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->priv->after = (self->priv->g_destroy_func (self->priv->after), NULL));
3754         ((self->priv->before == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->priv->before = (self->priv->g_destroy_func (self->priv->before), NULL));
3755 }
3756
3757
3758 static GType gee_tree_set_range_get_type (void) {
3759         static volatile gsize gee_tree_set_range_type_id__volatile = 0;
3760         if (g_once_init_enter (&gee_tree_set_range_type_id__volatile)) {
3761                 static const GTypeValueTable g_define_type_value_table = { gee_tree_set_value_range_init, gee_tree_set_value_range_free_value, gee_tree_set_value_range_copy_value, gee_tree_set_value_range_peek_pointer, "p", gee_tree_set_value_range_collect_value, "p", gee_tree_set_value_range_lcopy_value };
3762                 static const GTypeInfo g_define_type_info = { sizeof (GeeTreeSetRangeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_tree_set_range_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeTreeSetRange), 0, (GInstanceInitFunc) gee_tree_set_range_instance_init, &g_define_type_value_table };
3763                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
3764                 GType gee_tree_set_range_type_id;
3765                 gee_tree_set_range_type_id = g_type_register_fundamental (g_type_fundamental_next (), "GeeTreeSetRange", &g_define_type_info, &g_define_type_fundamental_info, 0);
3766                 g_once_init_leave (&gee_tree_set_range_type_id__volatile, gee_tree_set_range_type_id);
3767         }
3768         return gee_tree_set_range_type_id__volatile;
3769 }
3770
3771
3772 static gpointer gee_tree_set_range_ref (gpointer instance) {
3773         GeeTreeSetRange* self;
3774         self = instance;
3775         g_atomic_int_inc (&self->ref_count);
3776         return instance;
3777 }
3778
3779
3780 static void gee_tree_set_range_unref (gpointer instance) {
3781         GeeTreeSetRange* self;
3782         self = instance;
3783         if (g_atomic_int_dec_and_test (&self->ref_count)) {
3784                 GEE_TREE_SET_RANGE_GET_CLASS (self)->finalize (self);
3785                 g_type_free_instance ((GTypeInstance *) self);
3786         }
3787 }
3788
3789
3790 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before) {
3791         GeeTreeSetSubSet * self = NULL;
3792         GeeTreeSet* _tmp0_;
3793         GeeTreeSet* _tmp1_;
3794         GeeTreeSet* _tmp2_;
3795         gconstpointer _tmp3_;
3796         gconstpointer _tmp4_;
3797         GeeTreeSetRange* _tmp5_;
3798         g_return_val_if_fail (set != NULL, NULL);
3799         self = (GeeTreeSetSubSet*) gee_abstract_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
3800         self->priv->g_type = g_type;
3801         self->priv->g_dup_func = g_dup_func;
3802         self->priv->g_destroy_func = g_destroy_func;
3803         _tmp0_ = set;
3804         _tmp1_ = _g_object_ref0 (_tmp0_);
3805         _g_object_unref0 (self->priv->set);
3806         self->priv->set = _tmp1_;
3807         _tmp2_ = set;
3808         _tmp3_ = after;
3809         _tmp4_ = before;
3810         _tmp5_ = gee_tree_set_range_new (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp2_, _tmp3_, _tmp4_);
3811         _gee_tree_set_range_unref0 (self->priv->range);
3812         self->priv->range = _tmp5_;
3813         return self;
3814 }
3815
3816
3817 static GeeTreeSetSubSet* gee_tree_set_sub_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after, gconstpointer before) {
3818         return gee_tree_set_sub_set_construct (GEE_TREE_SET_TYPE_SUB_SET, g_type, g_dup_func, g_destroy_func, set, after, before);
3819 }
3820
3821
3822 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before) {
3823         GeeTreeSetSubSet * self = NULL;
3824         GeeTreeSet* _tmp0_;
3825         GeeTreeSet* _tmp1_;
3826         GeeTreeSet* _tmp2_;
3827         gconstpointer _tmp3_;
3828         GeeTreeSetRange* _tmp4_;
3829         g_return_val_if_fail (set != NULL, NULL);
3830         self = (GeeTreeSetSubSet*) gee_abstract_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
3831         self->priv->g_type = g_type;
3832         self->priv->g_dup_func = g_dup_func;
3833         self->priv->g_destroy_func = g_destroy_func;
3834         _tmp0_ = set;
3835         _tmp1_ = _g_object_ref0 (_tmp0_);
3836         _g_object_unref0 (self->priv->set);
3837         self->priv->set = _tmp1_;
3838         _tmp2_ = set;
3839         _tmp3_ = before;
3840         _tmp4_ = gee_tree_set_range_new_head (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp2_, _tmp3_);
3841         _gee_tree_set_range_unref0 (self->priv->range);
3842         self->priv->range = _tmp4_;
3843         return self;
3844 }
3845
3846
3847 static GeeTreeSetSubSet* gee_tree_set_sub_set_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer before) {
3848         return gee_tree_set_sub_set_construct_head (GEE_TREE_SET_TYPE_SUB_SET, g_type, g_dup_func, g_destroy_func, set, before);
3849 }
3850
3851
3852 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct_tail (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after) {
3853         GeeTreeSetSubSet * self = NULL;
3854         GeeTreeSet* _tmp0_;
3855         GeeTreeSet* _tmp1_;
3856         GeeTreeSet* _tmp2_;
3857         gconstpointer _tmp3_;
3858         GeeTreeSetRange* _tmp4_;
3859         g_return_val_if_fail (set != NULL, NULL);
3860         self = (GeeTreeSetSubSet*) gee_abstract_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
3861         self->priv->g_type = g_type;
3862         self->priv->g_dup_func = g_dup_func;
3863         self->priv->g_destroy_func = g_destroy_func;
3864         _tmp0_ = set;
3865         _tmp1_ = _g_object_ref0 (_tmp0_);
3866         _g_object_unref0 (self->priv->set);
3867         self->priv->set = _tmp1_;
3868         _tmp2_ = set;
3869         _tmp3_ = after;
3870         _tmp4_ = gee_tree_set_range_new_tail (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp2_, _tmp3_);
3871         _gee_tree_set_range_unref0 (self->priv->range);
3872         self->priv->range = _tmp4_;
3873         return self;
3874 }
3875
3876
3877 static GeeTreeSetSubSet* gee_tree_set_sub_set_new_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, gconstpointer after) {
3878         return gee_tree_set_sub_set_construct_tail (GEE_TREE_SET_TYPE_SUB_SET, g_type, g_dup_func, g_destroy_func, set, after);
3879 }
3880
3881
3882 static GeeTreeSetSubSet* gee_tree_set_sub_set_construct_from_range (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range) {
3883         GeeTreeSetSubSet * self = NULL;
3884         GeeTreeSet* _tmp0_;
3885         GeeTreeSet* _tmp1_;
3886         GeeTreeSetRange* _tmp2_;
3887         GeeTreeSetRange* _tmp3_;
3888         g_return_val_if_fail (set != NULL, NULL);
3889         g_return_val_if_fail (range != NULL, NULL);
3890         self = (GeeTreeSetSubSet*) gee_abstract_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
3891         self->priv->g_type = g_type;
3892         self->priv->g_dup_func = g_dup_func;
3893         self->priv->g_destroy_func = g_destroy_func;
3894         _tmp0_ = set;
3895         _tmp1_ = _g_object_ref0 (_tmp0_);
3896         _g_object_unref0 (self->priv->set);
3897         self->priv->set = _tmp1_;
3898         _tmp2_ = range;
3899         _tmp3_ = _gee_tree_set_range_ref0 (_tmp2_);
3900         _gee_tree_set_range_unref0 (self->priv->range);
3901         self->priv->range = _tmp3_;
3902         return self;
3903 }
3904
3905
3906 static GeeTreeSetSubSet* gee_tree_set_sub_set_new_from_range (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range) {
3907         return gee_tree_set_sub_set_construct_from_range (GEE_TREE_SET_TYPE_SUB_SET, g_type, g_dup_func, g_destroy_func, set, range);
3908 }
3909
3910
3911 static gboolean gee_tree_set_sub_set_real_contains (GeeAbstractCollection* base, gconstpointer item) {
3912         GeeTreeSetSubSet * self;
3913         gboolean result = FALSE;
3914         gboolean _tmp0_ = FALSE;
3915         GeeTreeSetRange* _tmp1_;
3916         gconstpointer _tmp2_;
3917         gboolean _tmp3_ = FALSE;
3918         gboolean _tmp7_;
3919         self = (GeeTreeSetSubSet*) base;
3920         _tmp1_ = self->priv->range;
3921         _tmp2_ = item;
3922         _tmp3_ = gee_tree_set_range_in_range (_tmp1_, _tmp2_);
3923         if (_tmp3_) {
3924                 GeeTreeSet* _tmp4_;
3925                 gconstpointer _tmp5_;
3926                 gboolean _tmp6_ = FALSE;
3927                 _tmp4_ = self->priv->set;
3928                 _tmp5_ = item;
3929                 _tmp6_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _tmp4_, _tmp5_);
3930                 _tmp0_ = _tmp6_;
3931         } else {
3932                 _tmp0_ = FALSE;
3933         }
3934         _tmp7_ = _tmp0_;
3935         result = _tmp7_;
3936         return result;
3937 }
3938
3939
3940 static gboolean gee_tree_set_sub_set_real_add (GeeAbstractCollection* base, gconstpointer item) {
3941         GeeTreeSetSubSet * self;
3942         gboolean result = FALSE;
3943         gboolean _tmp0_ = FALSE;
3944         GeeTreeSetRange* _tmp1_;
3945         gconstpointer _tmp2_;
3946         gboolean _tmp3_ = FALSE;
3947         gboolean _tmp7_;
3948         self = (GeeTreeSetSubSet*) base;
3949         _tmp1_ = self->priv->range;
3950         _tmp2_ = item;
3951         _tmp3_ = gee_tree_set_range_in_range (_tmp1_, _tmp2_);
3952         if (_tmp3_) {
3953                 GeeTreeSet* _tmp4_;
3954                 gconstpointer _tmp5_;
3955                 gboolean _tmp6_ = FALSE;
3956                 _tmp4_ = self->priv->set;
3957                 _tmp5_ = item;
3958                 _tmp6_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp4_, _tmp5_);
3959                 _tmp0_ = _tmp6_;
3960         } else {
3961                 _tmp0_ = FALSE;
3962         }
3963         _tmp7_ = _tmp0_;
3964         result = _tmp7_;
3965         return result;
3966 }
3967
3968
3969 static gboolean gee_tree_set_sub_set_real_remove (GeeAbstractCollection* base, gconstpointer item) {
3970         GeeTreeSetSubSet * self;
3971         gboolean result = FALSE;
3972         gboolean _tmp0_ = FALSE;
3973         GeeTreeSetRange* _tmp1_;
3974         gconstpointer _tmp2_;
3975         gboolean _tmp3_ = FALSE;
3976         gboolean _tmp7_;
3977         self = (GeeTreeSetSubSet*) base;
3978         _tmp1_ = self->priv->range;
3979         _tmp2_ = item;
3980         _tmp3_ = gee_tree_set_range_in_range (_tmp1_, _tmp2_);
3981         if (_tmp3_) {
3982                 GeeTreeSet* _tmp4_;
3983                 gconstpointer _tmp5_;
3984                 gboolean _tmp6_ = FALSE;
3985                 _tmp4_ = self->priv->set;
3986                 _tmp5_ = item;
3987                 _tmp6_ = gee_abstract_collection_remove ((GeeAbstractCollection*) _tmp4_, _tmp5_);
3988                 _tmp0_ = _tmp6_;
3989         } else {
3990                 _tmp0_ = FALSE;
3991         }
3992         _tmp7_ = _tmp0_;
3993         result = _tmp7_;
3994         return result;
3995 }
3996
3997
3998 static void gee_tree_set_sub_set_real_clear (GeeAbstractCollection* base) {
3999         GeeTreeSetSubSet * self;
4000         GeeIterator* _tmp0_ = NULL;
4001         GeeIterator* iter;
4002         self = (GeeTreeSetSubSet*) base;
4003         _tmp0_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) self);
4004         iter = _tmp0_;
4005         while (TRUE) {
4006                 GeeIterator* _tmp1_;
4007                 gboolean _tmp2_ = FALSE;
4008                 GeeIterator* _tmp3_;
4009                 _tmp1_ = iter;
4010                 _tmp2_ = gee_iterator_next (_tmp1_);
4011                 if (!_tmp2_) {
4012                         break;
4013                 }
4014                 _tmp3_ = iter;
4015                 gee_iterator_remove (_tmp3_);
4016         }
4017         _g_object_unref0 (iter);
4018 }
4019
4020
4021 static GeeIterator* gee_tree_set_sub_set_real_iterator (GeeAbstractCollection* base) {
4022         GeeTreeSetSubSet * self;
4023         GeeIterator* result = NULL;
4024         GeeTreeSet* _tmp0_;
4025         GeeTreeSetRange* _tmp1_;
4026         GeeTreeSetSubIterator* _tmp2_;
4027         self = (GeeTreeSetSubSet*) base;
4028         _tmp0_ = self->priv->set;
4029         _tmp1_ = self->priv->range;
4030         _tmp2_ = gee_tree_set_sub_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp0_, _tmp1_);
4031         result = (GeeIterator*) _tmp2_;
4032         return result;
4033 }
4034
4035
4036 static GeeBidirIterator* gee_tree_set_sub_set_real_bidir_iterator (GeeSortedSet* base) {
4037         GeeTreeSetSubSet * self;
4038         GeeBidirIterator* result = NULL;
4039         GeeTreeSet* _tmp0_;
4040         GeeTreeSetRange* _tmp1_;
4041         GeeTreeSetSubIterator* _tmp2_;
4042         self = (GeeTreeSetSubSet*) base;
4043         _tmp0_ = self->priv->set;
4044         _tmp1_ = self->priv->range;
4045         _tmp2_ = gee_tree_set_sub_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp0_, _tmp1_);
4046         result = (GeeBidirIterator*) _tmp2_;
4047         return result;
4048 }
4049
4050
4051 static gpointer gee_tree_set_sub_set_real_first (GeeSortedSet* base) {
4052         GeeTreeSetSubSet * self;
4053         gpointer result = NULL;
4054         GeeTreeSetRange* _tmp0_;
4055         GeeTreeSetNode* _tmp1_ = NULL;
4056         GeeTreeSetNode* _first;
4057         gconstpointer _tmp2_;
4058         gpointer _tmp3_;
4059         self = (GeeTreeSetSubSet*) base;
4060         _tmp0_ = self->priv->range;
4061         _tmp1_ = gee_tree_set_range_first (_tmp0_);
4062         _first = _tmp1_;
4063         _vala_assert (_first != NULL, "_first != null");
4064         _tmp2_ = _first->key;
4065         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
4066         result = _tmp3_;
4067         return result;
4068 }
4069
4070
4071 static gpointer gee_tree_set_sub_set_real_last (GeeSortedSet* base) {
4072         GeeTreeSetSubSet * self;
4073         gpointer result = NULL;
4074         GeeTreeSetRange* _tmp0_;
4075         GeeTreeSetNode* _tmp1_ = NULL;
4076         GeeTreeSetNode* _last;
4077         gconstpointer _tmp2_;
4078         gpointer _tmp3_;
4079         self = (GeeTreeSetSubSet*) base;
4080         _tmp0_ = self->priv->range;
4081         _tmp1_ = gee_tree_set_range_last (_tmp0_);
4082         _last = _tmp1_;
4083         _vala_assert (_last != NULL, "_last != null");
4084         _tmp2_ = _last->key;
4085         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
4086         result = _tmp3_;
4087         return result;
4088 }
4089
4090
4091 static GeeSortedSet* gee_tree_set_sub_set_real_head_set (GeeSortedSet* base, gconstpointer before) {
4092         GeeTreeSetSubSet * self;
4093         GeeSortedSet* result = NULL;
4094         GeeTreeSet* _tmp0_;
4095         GeeTreeSetRange* _tmp1_;
4096         gconstpointer _tmp2_;
4097         GeeTreeSetRange* _tmp3_ = NULL;
4098         GeeTreeSetRange* _tmp4_;
4099         GeeTreeSetSubSet* _tmp5_;
4100         GeeSortedSet* _tmp6_;
4101         self = (GeeTreeSetSubSet*) base;
4102         _tmp0_ = self->priv->set;
4103         _tmp1_ = self->priv->range;
4104         _tmp2_ = before;
4105         _tmp3_ = gee_tree_set_range_cut_tail (_tmp1_, _tmp2_);
4106         _tmp4_ = _tmp3_;
4107         _tmp5_ = gee_tree_set_sub_set_new_from_range (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp0_, _tmp4_);
4108         _tmp6_ = (GeeSortedSet*) _tmp5_;
4109         _gee_tree_set_range_unref0 (_tmp4_);
4110         result = _tmp6_;
4111         return result;
4112 }
4113
4114
4115 static GeeSortedSet* gee_tree_set_sub_set_real_tail_set (GeeSortedSet* base, gconstpointer after) {
4116         GeeTreeSetSubSet * self;
4117         GeeSortedSet* result = NULL;
4118         GeeTreeSet* _tmp0_;
4119         GeeTreeSetRange* _tmp1_;
4120         gconstpointer _tmp2_;
4121         GeeTreeSetRange* _tmp3_ = NULL;
4122         GeeTreeSetRange* _tmp4_;
4123         GeeTreeSetSubSet* _tmp5_;
4124         GeeSortedSet* _tmp6_;
4125         self = (GeeTreeSetSubSet*) base;
4126         _tmp0_ = self->priv->set;
4127         _tmp1_ = self->priv->range;
4128         _tmp2_ = after;
4129         _tmp3_ = gee_tree_set_range_cut_head (_tmp1_, _tmp2_);
4130         _tmp4_ = _tmp3_;
4131         _tmp5_ = gee_tree_set_sub_set_new_from_range (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp0_, _tmp4_);
4132         _tmp6_ = (GeeSortedSet*) _tmp5_;
4133         _gee_tree_set_range_unref0 (_tmp4_);
4134         result = _tmp6_;
4135         return result;
4136 }
4137
4138
4139 static GeeSortedSet* gee_tree_set_sub_set_real_sub_set (GeeSortedSet* base, gconstpointer after, gconstpointer before) {
4140         GeeTreeSetSubSet * self;
4141         GeeSortedSet* result = NULL;
4142         GeeTreeSet* _tmp0_;
4143         GeeTreeSetRange* _tmp1_;
4144         gconstpointer _tmp2_;
4145         gconstpointer _tmp3_;
4146         GeeTreeSetRange* _tmp4_ = NULL;
4147         GeeTreeSetRange* _tmp5_;
4148         GeeTreeSetSubSet* _tmp6_;
4149         GeeSortedSet* _tmp7_;
4150         self = (GeeTreeSetSubSet*) base;
4151         _tmp0_ = self->priv->set;
4152         _tmp1_ = self->priv->range;
4153         _tmp2_ = after;
4154         _tmp3_ = before;
4155         _tmp4_ = gee_tree_set_range_cut (_tmp1_, _tmp2_, _tmp3_);
4156         _tmp5_ = _tmp4_;
4157         _tmp6_ = gee_tree_set_sub_set_new_from_range (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp0_, _tmp5_);
4158         _tmp7_ = (GeeSortedSet*) _tmp6_;
4159         _gee_tree_set_range_unref0 (_tmp5_);
4160         result = _tmp7_;
4161         return result;
4162 }
4163
4164
4165 static GeeBidirIterator* gee_tree_set_sub_set_real_iterator_at (GeeSortedSet* base, gconstpointer item) {
4166         GeeTreeSetSubSet * self;
4167         GeeBidirIterator* result = NULL;
4168         GeeTreeSetRange* _tmp0_;
4169         gconstpointer _tmp1_;
4170         gboolean _tmp2_ = FALSE;
4171         GeeTreeSet* _tmp3_;
4172         gconstpointer _tmp4_;
4173         GeeTreeSetNode* _tmp5_ = NULL;
4174         GeeTreeSetNode* n;
4175         GeeTreeSetNode* _tmp6_;
4176         GeeTreeSet* _tmp7_;
4177         GeeTreeSetRange* _tmp8_;
4178         GeeTreeSetNode* _tmp9_;
4179         GeeTreeSetSubIterator* _tmp10_;
4180         self = (GeeTreeSetSubSet*) base;
4181         _tmp0_ = self->priv->range;
4182         _tmp1_ = item;
4183         _tmp2_ = gee_tree_set_range_in_range (_tmp0_, _tmp1_);
4184         if (!_tmp2_) {
4185                 result = NULL;
4186                 return result;
4187         }
4188         _tmp3_ = self->priv->set;
4189         _tmp4_ = item;
4190         _tmp5_ = gee_tree_set_find_node (_tmp3_, _tmp4_);
4191         n = _tmp5_;
4192         _tmp6_ = n;
4193         if (_tmp6_ == NULL) {
4194                 result = NULL;
4195                 return result;
4196         }
4197         _tmp7_ = self->priv->set;
4198         _tmp8_ = self->priv->range;
4199         _tmp9_ = n;
4200         _tmp10_ = gee_tree_set_sub_iterator_new_pointing (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp7_, _tmp8_, _tmp9_);
4201         result = (GeeBidirIterator*) _tmp10_;
4202         return result;
4203 }
4204
4205
4206 static gpointer gee_tree_set_sub_set_real_lower (GeeSortedSet* base, gconstpointer item) {
4207         GeeTreeSetSubSet * self;
4208         gpointer result = NULL;
4209         GeeTreeSetRange* _tmp0_;
4210         gconstpointer _tmp1_;
4211         gint _tmp2_ = 0;
4212         gint res;
4213         gint _tmp3_;
4214         GeeTreeSet* _tmp5_;
4215         gconstpointer _tmp6_;
4216         gpointer _tmp7_ = NULL;
4217         gpointer l;
4218         gconstpointer _tmp8_ = NULL;
4219         gboolean _tmp9_ = FALSE;
4220         gconstpointer _tmp10_;
4221         gboolean _tmp14_;
4222         gconstpointer _tmp16_;
4223         gpointer _tmp17_;
4224         self = (GeeTreeSetSubSet*) base;
4225         _tmp0_ = self->priv->range;
4226         _tmp1_ = item;
4227         _tmp2_ = gee_tree_set_range_compare_range (_tmp0_, _tmp1_);
4228         res = _tmp2_;
4229         _tmp3_ = res;
4230         if (_tmp3_ > 0) {
4231                 gpointer _tmp4_ = NULL;
4232                 _tmp4_ = gee_sorted_set_last ((GeeSortedSet*) self);
4233                 result = _tmp4_;
4234                 return result;
4235         }
4236         _tmp5_ = self->priv->set;
4237         _tmp6_ = item;
4238         _tmp7_ = gee_sorted_set_lower ((GeeSortedSet*) _tmp5_, _tmp6_);
4239         l = _tmp7_;
4240         _tmp10_ = l;
4241         if (_tmp10_ != NULL) {
4242                 GeeTreeSetRange* _tmp11_;
4243                 gconstpointer _tmp12_;
4244                 gboolean _tmp13_ = FALSE;
4245                 _tmp11_ = self->priv->range;
4246                 _tmp12_ = l;
4247                 _tmp13_ = gee_tree_set_range_in_range (_tmp11_, _tmp12_);
4248                 _tmp9_ = _tmp13_;
4249         } else {
4250                 _tmp9_ = FALSE;
4251         }
4252         _tmp14_ = _tmp9_;
4253         if (_tmp14_) {
4254                 gconstpointer _tmp15_;
4255                 _tmp15_ = l;
4256                 _tmp8_ = _tmp15_;
4257         } else {
4258                 _tmp8_ = NULL;
4259         }
4260         _tmp16_ = _tmp8_;
4261         _tmp17_ = ((_tmp16_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp16_) : ((gpointer) _tmp16_);
4262         result = _tmp17_;
4263         ((l == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (l = (self->priv->g_destroy_func (l), NULL));
4264         return result;
4265 }
4266
4267
4268 static gpointer gee_tree_set_sub_set_real_higher (GeeSortedSet* base, gconstpointer item) {
4269         GeeTreeSetSubSet * self;
4270         gpointer result = NULL;
4271         GeeTreeSetRange* _tmp0_;
4272         gconstpointer _tmp1_;
4273         gint _tmp2_ = 0;
4274         gint res;
4275         gint _tmp3_;
4276         GeeTreeSet* _tmp5_;
4277         gconstpointer _tmp6_;
4278         gpointer _tmp7_ = NULL;
4279         gpointer h;
4280         gconstpointer _tmp8_ = NULL;
4281         gboolean _tmp9_ = FALSE;
4282         gconstpointer _tmp10_;
4283         gboolean _tmp14_;
4284         gconstpointer _tmp16_;
4285         gpointer _tmp17_;
4286         self = (GeeTreeSetSubSet*) base;
4287         _tmp0_ = self->priv->range;
4288         _tmp1_ = item;
4289         _tmp2_ = gee_tree_set_range_compare_range (_tmp0_, _tmp1_);
4290         res = _tmp2_;
4291         _tmp3_ = res;
4292         if (_tmp3_ < 0) {
4293                 gpointer _tmp4_ = NULL;
4294                 _tmp4_ = gee_sorted_set_first ((GeeSortedSet*) self);
4295                 result = _tmp4_;
4296                 return result;
4297         }
4298         _tmp5_ = self->priv->set;
4299         _tmp6_ = item;
4300         _tmp7_ = gee_sorted_set_higher ((GeeSortedSet*) _tmp5_, _tmp6_);
4301         h = _tmp7_;
4302         _tmp10_ = h;
4303         if (_tmp10_ != NULL) {
4304                 GeeTreeSetRange* _tmp11_;
4305                 gconstpointer _tmp12_;
4306                 gboolean _tmp13_ = FALSE;
4307                 _tmp11_ = self->priv->range;
4308                 _tmp12_ = h;
4309                 _tmp13_ = gee_tree_set_range_in_range (_tmp11_, _tmp12_);
4310                 _tmp9_ = _tmp13_;
4311         } else {
4312                 _tmp9_ = FALSE;
4313         }
4314         _tmp14_ = _tmp9_;
4315         if (_tmp14_) {
4316                 gconstpointer _tmp15_;
4317                 _tmp15_ = h;
4318                 _tmp8_ = _tmp15_;
4319         } else {
4320                 _tmp8_ = NULL;
4321         }
4322         _tmp16_ = _tmp8_;
4323         _tmp17_ = ((_tmp16_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp16_) : ((gpointer) _tmp16_);
4324         result = _tmp17_;
4325         ((h == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (h = (self->priv->g_destroy_func (h), NULL));
4326         return result;
4327 }
4328
4329
4330 static gpointer gee_tree_set_sub_set_real_floor (GeeSortedSet* base, gconstpointer item) {
4331         GeeTreeSetSubSet * self;
4332         gpointer result = NULL;
4333         GeeTreeSetRange* _tmp0_;
4334         gconstpointer _tmp1_;
4335         gint _tmp2_ = 0;
4336         gint res;
4337         gint _tmp3_;
4338         GeeTreeSet* _tmp5_;
4339         gconstpointer _tmp6_;
4340         gpointer _tmp7_ = NULL;
4341         gpointer l;
4342         gconstpointer _tmp8_ = NULL;
4343         gboolean _tmp9_ = FALSE;
4344         gconstpointer _tmp10_;
4345         gboolean _tmp14_;
4346         gconstpointer _tmp16_;
4347         gpointer _tmp17_;
4348         self = (GeeTreeSetSubSet*) base;
4349         _tmp0_ = self->priv->range;
4350         _tmp1_ = item;
4351         _tmp2_ = gee_tree_set_range_compare_range (_tmp0_, _tmp1_);
4352         res = _tmp2_;
4353         _tmp3_ = res;
4354         if (_tmp3_ > 0) {
4355                 gpointer _tmp4_ = NULL;
4356                 _tmp4_ = gee_sorted_set_last ((GeeSortedSet*) self);
4357                 result = _tmp4_;
4358                 return result;
4359         }
4360         _tmp5_ = self->priv->set;
4361         _tmp6_ = item;
4362         _tmp7_ = gee_sorted_set_floor ((GeeSortedSet*) _tmp5_, _tmp6_);
4363         l = _tmp7_;
4364         _tmp10_ = l;
4365         if (_tmp10_ != NULL) {
4366                 GeeTreeSetRange* _tmp11_;
4367                 gconstpointer _tmp12_;
4368                 gboolean _tmp13_ = FALSE;
4369                 _tmp11_ = self->priv->range;
4370                 _tmp12_ = l;
4371                 _tmp13_ = gee_tree_set_range_in_range (_tmp11_, _tmp12_);
4372                 _tmp9_ = _tmp13_;
4373         } else {
4374                 _tmp9_ = FALSE;
4375         }
4376         _tmp14_ = _tmp9_;
4377         if (_tmp14_) {
4378                 gconstpointer _tmp15_;
4379                 _tmp15_ = l;
4380                 _tmp8_ = _tmp15_;
4381         } else {
4382                 _tmp8_ = NULL;
4383         }
4384         _tmp16_ = _tmp8_;
4385         _tmp17_ = ((_tmp16_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp16_) : ((gpointer) _tmp16_);
4386         result = _tmp17_;
4387         ((l == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (l = (self->priv->g_destroy_func (l), NULL));
4388         return result;
4389 }
4390
4391
4392 static gpointer gee_tree_set_sub_set_real_ceil (GeeSortedSet* base, gconstpointer item) {
4393         GeeTreeSetSubSet * self;
4394         gpointer result = NULL;
4395         GeeTreeSetRange* _tmp0_;
4396         gconstpointer _tmp1_;
4397         gint _tmp2_ = 0;
4398         gint res;
4399         gint _tmp3_;
4400         GeeTreeSet* _tmp5_;
4401         gconstpointer _tmp6_;
4402         gpointer _tmp7_ = NULL;
4403         gpointer h;
4404         gconstpointer _tmp8_ = NULL;
4405         gboolean _tmp9_ = FALSE;
4406         gconstpointer _tmp10_;
4407         gboolean _tmp14_;
4408         gconstpointer _tmp16_;
4409         gpointer _tmp17_;
4410         self = (GeeTreeSetSubSet*) base;
4411         _tmp0_ = self->priv->range;
4412         _tmp1_ = item;
4413         _tmp2_ = gee_tree_set_range_compare_range (_tmp0_, _tmp1_);
4414         res = _tmp2_;
4415         _tmp3_ = res;
4416         if (_tmp3_ < 0) {
4417                 gpointer _tmp4_ = NULL;
4418                 _tmp4_ = gee_sorted_set_first ((GeeSortedSet*) self);
4419                 result = _tmp4_;
4420                 return result;
4421         }
4422         _tmp5_ = self->priv->set;
4423         _tmp6_ = item;
4424         _tmp7_ = gee_sorted_set_ceil ((GeeSortedSet*) _tmp5_, _tmp6_);
4425         h = _tmp7_;
4426         _tmp10_ = h;
4427         if (_tmp10_ != NULL) {
4428                 GeeTreeSetRange* _tmp11_;
4429                 gconstpointer _tmp12_;
4430                 gboolean _tmp13_ = FALSE;
4431                 _tmp11_ = self->priv->range;
4432                 _tmp12_ = h;
4433                 _tmp13_ = gee_tree_set_range_in_range (_tmp11_, _tmp12_);
4434                 _tmp9_ = _tmp13_;
4435         } else {
4436                 _tmp9_ = FALSE;
4437         }
4438         _tmp14_ = _tmp9_;
4439         if (_tmp14_) {
4440                 gconstpointer _tmp15_;
4441                 _tmp15_ = h;
4442                 _tmp8_ = _tmp15_;
4443         } else {
4444                 _tmp8_ = NULL;
4445         }
4446         _tmp16_ = _tmp8_;
4447         _tmp17_ = ((_tmp16_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp16_) : ((gpointer) _tmp16_);
4448         result = _tmp17_;
4449         ((h == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (h = (self->priv->g_destroy_func (h), NULL));
4450         return result;
4451 }
4452
4453
4454 static gint gee_tree_set_sub_set_real_get_size (GeeAbstractCollection* base) {
4455         gint result;
4456         GeeTreeSetSubSet* self;
4457         gint i;
4458         GeeIterator* _tmp0_ = NULL;
4459         GeeIterator* iterator;
4460         gint _tmp4_;
4461         self = (GeeTreeSetSubSet*) base;
4462         i = 0;
4463         _tmp0_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) self);
4464         iterator = _tmp0_;
4465         while (TRUE) {
4466                 GeeIterator* _tmp1_;
4467                 gboolean _tmp2_ = FALSE;
4468                 gint _tmp3_;
4469                 _tmp1_ = iterator;
4470                 _tmp2_ = gee_iterator_next (_tmp1_);
4471                 if (!_tmp2_) {
4472                         break;
4473                 }
4474                 _tmp3_ = i;
4475                 i = _tmp3_ + 1;
4476         }
4477         _tmp4_ = i;
4478         result = _tmp4_;
4479         _g_object_unref0 (iterator);
4480         return result;
4481 }
4482
4483
4484 static gboolean gee_tree_set_sub_set_real_get_is_empty (GeeAbstractCollection* base) {
4485         gboolean result;
4486         GeeTreeSetSubSet* self;
4487         GeeTreeSetRange* _tmp0_;
4488         gboolean _tmp1_ = FALSE;
4489         self = (GeeTreeSetSubSet*) base;
4490         _tmp0_ = self->priv->range;
4491         _tmp1_ = gee_tree_set_range_empty_subset (_tmp0_);
4492         result = _tmp1_;
4493         return result;
4494 }
4495
4496
4497 static void gee_tree_set_sub_set_class_init (GeeTreeSetSubSetClass * klass) {
4498         gee_tree_set_sub_set_parent_class = g_type_class_peek_parent (klass);
4499         g_type_class_add_private (klass, sizeof (GeeTreeSetSubSetPrivate));
4500         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_tree_set_sub_set_real_contains;
4501         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_tree_set_sub_set_real_add;
4502         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_tree_set_sub_set_real_remove;
4503         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_tree_set_sub_set_real_clear;
4504         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_tree_set_sub_set_real_iterator;
4505         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_tree_set_sub_set_real_get_size;
4506         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_is_empty = gee_tree_set_sub_set_real_get_is_empty;
4507         G_OBJECT_CLASS (klass)->get_property = _vala_gee_tree_set_sub_set_get_property;
4508         G_OBJECT_CLASS (klass)->set_property = _vala_gee_tree_set_sub_set_set_property;
4509         G_OBJECT_CLASS (klass)->finalize = gee_tree_set_sub_set_finalize;
4510         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_SET_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4511         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_SET_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4512         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_SET_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4513         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_SET_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
4514         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_SET_IS_EMPTY, g_param_spec_boolean ("is-empty", "is-empty", "is-empty", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
4515 }
4516
4517
4518 static void gee_tree_set_sub_set_gee_sorted_set_interface_init (GeeSortedSetIface * iface) {
4519         gee_tree_set_sub_set_gee_sorted_set_parent_iface = g_type_interface_peek_parent (iface);
4520         iface->bidir_iterator = (GeeBidirIterator* (*)(GeeSortedSet*)) gee_tree_set_sub_set_real_bidir_iterator;
4521         iface->first = (gpointer (*)(GeeSortedSet*)) gee_tree_set_sub_set_real_first;
4522         iface->last = (gpointer (*)(GeeSortedSet*)) gee_tree_set_sub_set_real_last;
4523         iface->head_set = (GeeSortedSet* (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_sub_set_real_head_set;
4524         iface->tail_set = (GeeSortedSet* (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_sub_set_real_tail_set;
4525         iface->sub_set = (GeeSortedSet* (*)(GeeSortedSet*, gconstpointer, gconstpointer)) gee_tree_set_sub_set_real_sub_set;
4526         iface->iterator_at = (GeeBidirIterator* (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_sub_set_real_iterator_at;
4527         iface->lower = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_sub_set_real_lower;
4528         iface->higher = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_sub_set_real_higher;
4529         iface->floor = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_sub_set_real_floor;
4530         iface->ceil = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_sub_set_real_ceil;
4531 }
4532
4533
4534 static void gee_tree_set_sub_set_instance_init (GeeTreeSetSubSet * self) {
4535         self->priv = GEE_TREE_SET_SUB_SET_GET_PRIVATE (self);
4536 }
4537
4538
4539 static void gee_tree_set_sub_set_finalize (GObject* obj) {
4540         GeeTreeSetSubSet * self;
4541         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TREE_SET_TYPE_SUB_SET, GeeTreeSetSubSet);
4542         _g_object_unref0 (self->priv->set);
4543         _gee_tree_set_range_unref0 (self->priv->range);
4544         G_OBJECT_CLASS (gee_tree_set_sub_set_parent_class)->finalize (obj);
4545 }
4546
4547
4548 static GType gee_tree_set_sub_set_get_type (void) {
4549         static volatile gsize gee_tree_set_sub_set_type_id__volatile = 0;
4550         if (g_once_init_enter (&gee_tree_set_sub_set_type_id__volatile)) {
4551                 static const GTypeInfo g_define_type_info = { sizeof (GeeTreeSetSubSetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_tree_set_sub_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeTreeSetSubSet), 0, (GInstanceInitFunc) gee_tree_set_sub_set_instance_init, NULL };
4552                 static const GInterfaceInfo gee_sorted_set_info = { (GInterfaceInitFunc) gee_tree_set_sub_set_gee_sorted_set_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4553                 GType gee_tree_set_sub_set_type_id;
4554                 gee_tree_set_sub_set_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_SET, "GeeTreeSetSubSet", &g_define_type_info, 0);
4555                 g_type_add_interface_static (gee_tree_set_sub_set_type_id, GEE_TYPE_SORTED_SET, &gee_sorted_set_info);
4556                 g_once_init_leave (&gee_tree_set_sub_set_type_id__volatile, gee_tree_set_sub_set_type_id);
4557         }
4558         return gee_tree_set_sub_set_type_id__volatile;
4559 }
4560
4561
4562 static void _vala_gee_tree_set_sub_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
4563         GeeTreeSetSubSet * self;
4564         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TREE_SET_TYPE_SUB_SET, GeeTreeSetSubSet);
4565         switch (property_id) {
4566                 case GEE_TREE_SET_SUB_SET_SIZE:
4567                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
4568                 break;
4569                 case GEE_TREE_SET_SUB_SET_IS_EMPTY:
4570                 g_value_set_boolean (value, gee_abstract_collection_get_is_empty ((GeeAbstractCollection*) self));
4571                 break;
4572                 default:
4573                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4574                 break;
4575         }
4576 }
4577
4578
4579 static void _vala_gee_tree_set_sub_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
4580         GeeTreeSetSubSet * self;
4581         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TREE_SET_TYPE_SUB_SET, GeeTreeSetSubSet);
4582         switch (property_id) {
4583                 case GEE_TREE_SET_SUB_SET_G_TYPE:
4584                 self->priv->g_type = g_value_get_gtype (value);
4585                 break;
4586                 case GEE_TREE_SET_SUB_SET_G_DUP_FUNC:
4587                 self->priv->g_dup_func = g_value_get_pointer (value);
4588                 break;
4589                 case GEE_TREE_SET_SUB_SET_G_DESTROY_FUNC:
4590                 self->priv->g_destroy_func = g_value_get_pointer (value);
4591                 break;
4592                 default:
4593                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4594                 break;
4595         }
4596 }
4597
4598
4599 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range) {
4600         GeeTreeSetSubIterator * self = NULL;
4601         GeeTreeSet* _tmp0_;
4602         GeeTreeSet* _tmp1_;
4603         GeeTreeSetRange* _tmp2_;
4604         GeeTreeSetRange* _tmp3_;
4605         g_return_val_if_fail (set != NULL, NULL);
4606         g_return_val_if_fail (range != NULL, NULL);
4607         self = (GeeTreeSetSubIterator*) g_object_new (object_type, NULL);
4608         self->priv->g_type = g_type;
4609         self->priv->g_dup_func = g_dup_func;
4610         self->priv->g_destroy_func = g_destroy_func;
4611         _tmp0_ = set;
4612         _tmp1_ = _g_object_ref0 (_tmp0_);
4613         _g_object_unref0 (self->priv->set);
4614         self->priv->set = _tmp1_;
4615         _tmp2_ = range;
4616         _tmp3_ = _gee_tree_set_range_ref0 (_tmp2_);
4617         _gee_tree_set_range_unref0 (self->priv->range);
4618         self->priv->range = _tmp3_;
4619         return self;
4620 }
4621
4622
4623 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range) {
4624         return gee_tree_set_sub_iterator_construct (GEE_TREE_SET_TYPE_SUB_ITERATOR, g_type, g_dup_func, g_destroy_func, set, range);
4625 }
4626
4627
4628 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_construct_pointing (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range, GeeTreeSetNode* node) {
4629         GeeTreeSetSubIterator * self = NULL;
4630         GeeTreeSet* _tmp0_;
4631         GeeTreeSet* _tmp1_;
4632         GeeTreeSetRange* _tmp2_;
4633         GeeTreeSetRange* _tmp3_;
4634         GeeTreeSet* _tmp4_;
4635         GeeTreeSetNode* _tmp5_;
4636         GeeTreeSetIterator* _tmp6_;
4637         g_return_val_if_fail (set != NULL, NULL);
4638         g_return_val_if_fail (range != NULL, NULL);
4639         g_return_val_if_fail (node != NULL, NULL);
4640         self = (GeeTreeSetSubIterator*) g_object_new (object_type, NULL);
4641         self->priv->g_type = g_type;
4642         self->priv->g_dup_func = g_dup_func;
4643         self->priv->g_destroy_func = g_destroy_func;
4644         _tmp0_ = set;
4645         _tmp1_ = _g_object_ref0 (_tmp0_);
4646         _g_object_unref0 (self->priv->set);
4647         self->priv->set = _tmp1_;
4648         _tmp2_ = range;
4649         _tmp3_ = _gee_tree_set_range_ref0 (_tmp2_);
4650         _gee_tree_set_range_unref0 (self->priv->range);
4651         self->priv->range = _tmp3_;
4652         _tmp4_ = set;
4653         _tmp5_ = node;
4654         _tmp6_ = gee_tree_set_iterator_new_pointing (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp4_, _tmp5_);
4655         _g_object_unref0 (self->priv->iterator);
4656         self->priv->iterator = _tmp6_;
4657         return self;
4658 }
4659
4660
4661 static GeeTreeSetSubIterator* gee_tree_set_sub_iterator_new_pointing (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeTreeSet* set, GeeTreeSetRange* range, GeeTreeSetNode* node) {
4662         return gee_tree_set_sub_iterator_construct_pointing (GEE_TREE_SET_TYPE_SUB_ITERATOR, g_type, g_dup_func, g_destroy_func, set, range, node);
4663 }
4664
4665
4666 static gboolean gee_tree_set_sub_iterator_real_next (GeeIterator* base) {
4667         GeeTreeSetSubIterator * self;
4668         gboolean result = FALSE;
4669         GeeTreeSetIterator* _tmp0_;
4670         self = (GeeTreeSetSubIterator*) base;
4671         _tmp0_ = self->priv->iterator;
4672         if (_tmp0_ != NULL) {
4673                 gpointer next = NULL;
4674                 gboolean _tmp1_ = FALSE;
4675                 GeeTreeSetIterator* _tmp2_;
4676                 gpointer _tmp3_ = NULL;
4677                 gboolean _tmp4_ = FALSE;
4678                 gboolean _tmp8_;
4679                 _tmp2_ = self->priv->iterator;
4680                 _tmp4_ = gee_tree_set_iterator_safe_next_get (_tmp2_, &_tmp3_);
4681                 ((next == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (next = (self->priv->g_destroy_func (next), NULL));
4682                 next = _tmp3_;
4683                 if (_tmp4_) {
4684                         GeeTreeSetRange* _tmp5_;
4685                         gconstpointer _tmp6_;
4686                         gboolean _tmp7_ = FALSE;
4687                         _tmp5_ = self->priv->range;
4688                         _tmp6_ = next;
4689                         _tmp7_ = gee_tree_set_range_in_range (_tmp5_, _tmp6_);
4690                         _tmp1_ = _tmp7_;
4691                 } else {
4692                         _tmp1_ = FALSE;
4693                 }
4694                 _tmp8_ = _tmp1_;
4695                 if (_tmp8_) {
4696                         GeeTreeSetIterator* _tmp9_;
4697                         gboolean _tmp10_ = FALSE;
4698                         _tmp9_ = self->priv->iterator;
4699                         _tmp10_ = gee_iterator_next ((GeeIterator*) _tmp9_);
4700                         _vala_assert (_tmp10_, "iterator.next ()");
4701                         result = TRUE;
4702                         ((next == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (next = (self->priv->g_destroy_func (next), NULL));
4703                         return result;
4704                 } else {
4705                         result = FALSE;
4706                         ((next == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (next = (self->priv->g_destroy_func (next), NULL));
4707                         return result;
4708                 }
4709                 ((next == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (next = (self->priv->g_destroy_func (next), NULL));
4710         } else {
4711                 gboolean _tmp11_ = FALSE;
4712                 _tmp11_ = gee_iterator_first ((GeeIterator*) self);
4713                 result = _tmp11_;
4714                 return result;
4715         }
4716 }
4717
4718
4719 static gboolean gee_tree_set_sub_iterator_real_has_next (GeeIterator* base) {
4720         GeeTreeSetSubIterator * self;
4721         gboolean result = FALSE;
4722         GeeTreeSetIterator* _tmp0_;
4723         self = (GeeTreeSetSubIterator*) base;
4724         _tmp0_ = self->priv->iterator;
4725         if (_tmp0_ != NULL) {
4726                 gpointer next = NULL;
4727                 gboolean _tmp1_ = FALSE;
4728                 GeeTreeSetIterator* _tmp2_;
4729                 gpointer _tmp3_ = NULL;
4730                 gboolean _tmp4_ = FALSE;
4731                 gboolean _tmp8_;
4732                 _tmp2_ = self->priv->iterator;
4733                 _tmp4_ = gee_tree_set_iterator_safe_next_get (_tmp2_, &_tmp3_);
4734                 ((next == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (next = (self->priv->g_destroy_func (next), NULL));
4735                 next = _tmp3_;
4736                 if (_tmp4_) {
4737                         GeeTreeSetRange* _tmp5_;
4738                         gconstpointer _tmp6_;
4739                         gboolean _tmp7_ = FALSE;
4740                         _tmp5_ = self->priv->range;
4741                         _tmp6_ = next;
4742                         _tmp7_ = gee_tree_set_range_in_range (_tmp5_, _tmp6_);
4743                         _tmp1_ = _tmp7_;
4744                 } else {
4745                         _tmp1_ = FALSE;
4746                 }
4747                 _tmp8_ = _tmp1_;
4748                 result = _tmp8_;
4749                 ((next == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (next = (self->priv->g_destroy_func (next), NULL));
4750                 return result;
4751         } else {
4752                 GeeTreeSetRange* _tmp9_;
4753                 GeeTreeSetNode* _tmp10_ = NULL;
4754                 _tmp9_ = self->priv->range;
4755                 _tmp10_ = gee_tree_set_range_first (_tmp9_);
4756                 result = _tmp10_ != NULL;
4757                 return result;
4758         }
4759 }
4760
4761
4762 static gboolean gee_tree_set_sub_iterator_real_first (GeeIterator* base) {
4763         GeeTreeSetSubIterator * self;
4764         gboolean result = FALSE;
4765         GeeTreeSetRange* _tmp0_;
4766         GeeTreeSetNode* _tmp1_ = NULL;
4767         GeeTreeSetNode* node;
4768         GeeTreeSetNode* _tmp2_;
4769         GeeTreeSet* _tmp3_;
4770         GeeTreeSetNode* _tmp4_;
4771         GeeTreeSetIterator* _tmp5_;
4772         self = (GeeTreeSetSubIterator*) base;
4773         _tmp0_ = self->priv->range;
4774         _tmp1_ = gee_tree_set_range_first (_tmp0_);
4775         node = _tmp1_;
4776         _tmp2_ = node;
4777         if (_tmp2_ == NULL) {
4778                 result = FALSE;
4779                 return result;
4780         }
4781         _tmp3_ = self->priv->set;
4782         _tmp4_ = node;
4783         _tmp5_ = gee_tree_set_iterator_new_pointing (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp4_);
4784         _g_object_unref0 (self->priv->iterator);
4785         self->priv->iterator = _tmp5_;
4786         result = TRUE;
4787         return result;
4788 }
4789
4790
4791 static gboolean gee_tree_set_sub_iterator_real_previous (GeeBidirIterator* base) {
4792         GeeTreeSetSubIterator * self;
4793         gboolean result = FALSE;
4794         GeeTreeSetIterator* _tmp0_;
4795         gpointer prev = NULL;
4796         gboolean _tmp1_ = FALSE;
4797         GeeTreeSetIterator* _tmp2_;
4798         gpointer _tmp3_ = NULL;
4799         gboolean _tmp4_ = FALSE;
4800         gboolean _tmp8_;
4801         self = (GeeTreeSetSubIterator*) base;
4802         _tmp0_ = self->priv->iterator;
4803         if (_tmp0_ == NULL) {
4804                 result = FALSE;
4805                 return result;
4806         }
4807         _tmp2_ = self->priv->iterator;
4808         _tmp4_ = gee_tree_set_iterator_safe_previous_get (_tmp2_, &_tmp3_);
4809         ((prev == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (prev = (self->priv->g_destroy_func (prev), NULL));
4810         prev = _tmp3_;
4811         if (_tmp4_) {
4812                 GeeTreeSetRange* _tmp5_;
4813                 gconstpointer _tmp6_;
4814                 gboolean _tmp7_ = FALSE;
4815                 _tmp5_ = self->priv->range;
4816                 _tmp6_ = prev;
4817                 _tmp7_ = gee_tree_set_range_in_range (_tmp5_, _tmp6_);
4818                 _tmp1_ = _tmp7_;
4819         } else {
4820                 _tmp1_ = FALSE;
4821         }
4822         _tmp8_ = _tmp1_;
4823         if (_tmp8_) {
4824                 GeeTreeSetIterator* _tmp9_;
4825                 gboolean _tmp10_ = FALSE;
4826                 _tmp9_ = self->priv->iterator;
4827                 _tmp10_ = gee_bidir_iterator_previous ((GeeBidirIterator*) _tmp9_);
4828                 _vala_assert (_tmp10_, "iterator.previous ()");
4829                 result = TRUE;
4830                 ((prev == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (prev = (self->priv->g_destroy_func (prev), NULL));
4831                 return result;
4832         } else {
4833                 result = FALSE;
4834                 ((prev == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (prev = (self->priv->g_destroy_func (prev), NULL));
4835                 return result;
4836         }
4837         ((prev == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (prev = (self->priv->g_destroy_func (prev), NULL));
4838 }
4839
4840
4841 static gboolean gee_tree_set_sub_iterator_real_has_previous (GeeBidirIterator* base) {
4842         GeeTreeSetSubIterator * self;
4843         gboolean result = FALSE;
4844         GeeTreeSetIterator* _tmp0_;
4845         gpointer prev = NULL;
4846         gboolean _tmp1_ = FALSE;
4847         GeeTreeSetIterator* _tmp2_;
4848         gpointer _tmp3_ = NULL;
4849         gboolean _tmp4_ = FALSE;
4850         gboolean _tmp8_;
4851         self = (GeeTreeSetSubIterator*) base;
4852         _tmp0_ = self->priv->iterator;
4853         if (_tmp0_ == NULL) {
4854                 result = FALSE;
4855                 return result;
4856         }
4857         _tmp2_ = self->priv->iterator;
4858         _tmp4_ = gee_tree_set_iterator_safe_previous_get (_tmp2_, &_tmp3_);
4859         ((prev == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (prev = (self->priv->g_destroy_func (prev), NULL));
4860         prev = _tmp3_;
4861         if (_tmp4_) {
4862                 GeeTreeSetRange* _tmp5_;
4863                 gconstpointer _tmp6_;
4864                 gboolean _tmp7_ = FALSE;
4865                 _tmp5_ = self->priv->range;
4866                 _tmp6_ = prev;
4867                 _tmp7_ = gee_tree_set_range_in_range (_tmp5_, _tmp6_);
4868                 _tmp1_ = _tmp7_;
4869         } else {
4870                 _tmp1_ = FALSE;
4871         }
4872         _tmp8_ = _tmp1_;
4873         result = _tmp8_;
4874         ((prev == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (prev = (self->priv->g_destroy_func (prev), NULL));
4875         return result;
4876 }
4877
4878
4879 static gboolean gee_tree_set_sub_iterator_real_last (GeeBidirIterator* base) {
4880         GeeTreeSetSubIterator * self;
4881         gboolean result = FALSE;
4882         GeeTreeSetRange* _tmp0_;
4883         GeeTreeSetNode* _tmp1_ = NULL;
4884         GeeTreeSetNode* node;
4885         GeeTreeSetNode* _tmp2_;
4886         GeeTreeSet* _tmp3_;
4887         GeeTreeSetNode* _tmp4_;
4888         GeeTreeSetIterator* _tmp5_;
4889         self = (GeeTreeSetSubIterator*) base;
4890         _tmp0_ = self->priv->range;
4891         _tmp1_ = gee_tree_set_range_last (_tmp0_);
4892         node = _tmp1_;
4893         _tmp2_ = node;
4894         if (_tmp2_ == NULL) {
4895                 result = FALSE;
4896                 return result;
4897         }
4898         _tmp3_ = self->priv->set;
4899         _tmp4_ = node;
4900         _tmp5_ = gee_tree_set_iterator_new_pointing (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp4_);
4901         _g_object_unref0 (self->priv->iterator);
4902         self->priv->iterator = _tmp5_;
4903         result = TRUE;
4904         return result;
4905 }
4906
4907
4908 static gpointer gee_tree_set_sub_iterator_real_get (GeeIterator* base) {
4909         GeeTreeSetSubIterator * self;
4910         gpointer result = NULL;
4911         GeeTreeSetIterator* _tmp0_;
4912         GeeTreeSetIterator* _tmp1_;
4913         gpointer _tmp2_ = NULL;
4914         self = (GeeTreeSetSubIterator*) base;
4915         _tmp0_ = self->priv->iterator;
4916         _vala_assert (_tmp0_ != NULL, "iterator != null");
4917         _tmp1_ = self->priv->iterator;
4918         _tmp2_ = gee_iterator_get ((GeeIterator*) _tmp1_);
4919         result = _tmp2_;
4920         return result;
4921 }
4922
4923
4924 static void gee_tree_set_sub_iterator_real_remove (GeeIterator* base) {
4925         GeeTreeSetSubIterator * self;
4926         GeeTreeSetIterator* _tmp0_;
4927         GeeTreeSetIterator* _tmp1_;
4928         self = (GeeTreeSetSubIterator*) base;
4929         _tmp0_ = self->priv->iterator;
4930         _vala_assert (_tmp0_ != NULL, "iterator != null");
4931         _tmp1_ = self->priv->iterator;
4932         gee_iterator_remove ((GeeIterator*) _tmp1_);
4933 }
4934
4935
4936 static void gee_tree_set_sub_iterator_class_init (GeeTreeSetSubIteratorClass * klass) {
4937         gee_tree_set_sub_iterator_parent_class = g_type_class_peek_parent (klass);
4938         g_type_class_add_private (klass, sizeof (GeeTreeSetSubIteratorPrivate));
4939         G_OBJECT_CLASS (klass)->get_property = _vala_gee_tree_set_sub_iterator_get_property;
4940         G_OBJECT_CLASS (klass)->set_property = _vala_gee_tree_set_sub_iterator_set_property;
4941         G_OBJECT_CLASS (klass)->finalize = gee_tree_set_sub_iterator_finalize;
4942         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_ITERATOR_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4943         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_ITERATOR_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4944         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SUB_ITERATOR_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4945 }
4946
4947
4948 static void gee_tree_set_sub_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
4949         gee_tree_set_sub_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
4950         iface->next = (gboolean (*)(GeeIterator*)) gee_tree_set_sub_iterator_real_next;
4951         iface->has_next = (gboolean (*)(GeeIterator*)) gee_tree_set_sub_iterator_real_has_next;
4952         iface->first = (gboolean (*)(GeeIterator*)) gee_tree_set_sub_iterator_real_first;
4953         iface->get = (gpointer (*)(GeeIterator*)) gee_tree_set_sub_iterator_real_get;
4954         iface->remove = (void (*)(GeeIterator*)) gee_tree_set_sub_iterator_real_remove;
4955 }
4956
4957
4958 static void gee_tree_set_sub_iterator_gee_bidir_iterator_interface_init (GeeBidirIteratorIface * iface) {
4959         gee_tree_set_sub_iterator_gee_bidir_iterator_parent_iface = g_type_interface_peek_parent (iface);
4960         iface->previous = (gboolean (*)(GeeBidirIterator*)) gee_tree_set_sub_iterator_real_previous;
4961         iface->has_previous = (gboolean (*)(GeeBidirIterator*)) gee_tree_set_sub_iterator_real_has_previous;
4962         iface->last = (gboolean (*)(GeeBidirIterator*)) gee_tree_set_sub_iterator_real_last;
4963 }
4964
4965
4966 static void gee_tree_set_sub_iterator_instance_init (GeeTreeSetSubIterator * self) {
4967         self->priv = GEE_TREE_SET_SUB_ITERATOR_GET_PRIVATE (self);
4968         self->priv->iterator = NULL;
4969 }
4970
4971
4972 static void gee_tree_set_sub_iterator_finalize (GObject* obj) {
4973         GeeTreeSetSubIterator * self;
4974         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TREE_SET_TYPE_SUB_ITERATOR, GeeTreeSetSubIterator);
4975         _g_object_unref0 (self->priv->set);
4976         _gee_tree_set_range_unref0 (self->priv->range);
4977         _g_object_unref0 (self->priv->iterator);
4978         G_OBJECT_CLASS (gee_tree_set_sub_iterator_parent_class)->finalize (obj);
4979 }
4980
4981
4982 static GType gee_tree_set_sub_iterator_get_type (void) {
4983         static volatile gsize gee_tree_set_sub_iterator_type_id__volatile = 0;
4984         if (g_once_init_enter (&gee_tree_set_sub_iterator_type_id__volatile)) {
4985                 static const GTypeInfo g_define_type_info = { sizeof (GeeTreeSetSubIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_tree_set_sub_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeTreeSetSubIterator), 0, (GInstanceInitFunc) gee_tree_set_sub_iterator_instance_init, NULL };
4986                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_tree_set_sub_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4987                 static const GInterfaceInfo gee_bidir_iterator_info = { (GInterfaceInitFunc) gee_tree_set_sub_iterator_gee_bidir_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4988                 GType gee_tree_set_sub_iterator_type_id;
4989                 gee_tree_set_sub_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeTreeSetSubIterator", &g_define_type_info, 0);
4990                 g_type_add_interface_static (gee_tree_set_sub_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
4991                 g_type_add_interface_static (gee_tree_set_sub_iterator_type_id, GEE_TYPE_BIDIR_ITERATOR, &gee_bidir_iterator_info);
4992                 g_once_init_leave (&gee_tree_set_sub_iterator_type_id__volatile, gee_tree_set_sub_iterator_type_id);
4993         }
4994         return gee_tree_set_sub_iterator_type_id__volatile;
4995 }
4996
4997
4998 static void _vala_gee_tree_set_sub_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
4999         GeeTreeSetSubIterator * self;
5000         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TREE_SET_TYPE_SUB_ITERATOR, GeeTreeSetSubIterator);
5001         switch (property_id) {
5002                 default:
5003                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
5004                 break;
5005         }
5006 }
5007
5008
5009 static void _vala_gee_tree_set_sub_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
5010         GeeTreeSetSubIterator * self;
5011         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TREE_SET_TYPE_SUB_ITERATOR, GeeTreeSetSubIterator);
5012         switch (property_id) {
5013                 case GEE_TREE_SET_SUB_ITERATOR_G_TYPE:
5014                 self->priv->g_type = g_value_get_gtype (value);
5015                 break;
5016                 case GEE_TREE_SET_SUB_ITERATOR_G_DUP_FUNC:
5017                 self->priv->g_dup_func = g_value_get_pointer (value);
5018                 break;
5019                 case GEE_TREE_SET_SUB_ITERATOR_G_DESTROY_FUNC:
5020                 self->priv->g_destroy_func = g_value_get_pointer (value);
5021                 break;
5022                 default:
5023                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
5024                 break;
5025         }
5026 }
5027
5028
5029 static void gee_tree_set_class_init (GeeTreeSetClass * klass) {
5030         gee_tree_set_parent_class = g_type_class_peek_parent (klass);
5031         g_type_class_add_private (klass, sizeof (GeeTreeSetPrivate));
5032         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_tree_set_real_contains;
5033         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_tree_set_real_add;
5034         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_tree_set_real_remove;
5035         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_tree_set_real_clear;
5036         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_tree_set_real_iterator;
5037         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_tree_set_real_get_size;
5038         G_OBJECT_CLASS (klass)->get_property = _vala_gee_tree_set_get_property;
5039         G_OBJECT_CLASS (klass)->set_property = _vala_gee_tree_set_set_property;
5040         G_OBJECT_CLASS (klass)->finalize = gee_tree_set_finalize;
5041         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
5042         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
5043         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
5044         /**
5045          * {@inheritDoc}
5046          */
5047         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
5048         /**
5049          * The elements' comparator function.
5050          */
5051         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_TREE_SET_COMPARE_FUNC, g_param_spec_pointer ("compare-func", "compare-func", "compare-func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
5052 }
5053
5054
5055 static void gee_tree_set_gee_sorted_set_interface_init (GeeSortedSetIface * iface) {
5056         gee_tree_set_gee_sorted_set_parent_iface = g_type_interface_peek_parent (iface);
5057         iface->bidir_iterator = (GeeBidirIterator* (*)(GeeSortedSet*)) gee_tree_set_real_bidir_iterator;
5058         iface->first = (gpointer (*)(GeeSortedSet*)) gee_tree_set_real_first;
5059         iface->last = (gpointer (*)(GeeSortedSet*)) gee_tree_set_real_last;
5060         iface->head_set = (GeeSortedSet* (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_real_head_set;
5061         iface->tail_set = (GeeSortedSet* (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_real_tail_set;
5062         iface->sub_set = (GeeSortedSet* (*)(GeeSortedSet*, gconstpointer, gconstpointer)) gee_tree_set_real_sub_set;
5063         iface->iterator_at = (GeeBidirIterator* (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_real_iterator_at;
5064         iface->lower = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_real_lower;
5065         iface->higher = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_real_higher;
5066         iface->floor = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_real_floor;
5067         iface->ceil = (gpointer (*)(GeeSortedSet*, gconstpointer)) gee_tree_set_real_ceil;
5068 }
5069
5070
5071 static void gee_tree_set_instance_init (GeeTreeSet * self) {
5072         self->priv = GEE_TREE_SET_GET_PRIVATE (self);
5073         self->priv->_size = 0;
5074         self->priv->root = NULL;
5075         self->priv->_first = NULL;
5076         self->priv->_last = NULL;
5077         self->priv->stamp = 0;
5078 }
5079
5080
5081 static void gee_tree_set_finalize (GObject* obj) {
5082         GeeTreeSet * self;
5083         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_TREE_SET, GeeTreeSet);
5084         _gee_tree_set_node_free0 (self->priv->root);
5085         G_OBJECT_CLASS (gee_tree_set_parent_class)->finalize (obj);
5086 }
5087
5088
5089 /**
5090  * Left-leaning red-black tree implementation of the {@link Set} interface.
5091  *
5092  * This implementation is especially well designed for large quantity of
5093  * data. The (balanced) tree implementation insure that the set and get
5094  * methods are in logarithmic complexity. For a linear implementation see
5095  * {@link HashSet}.
5096  *
5097  * @see HashSet
5098  */
5099 GType gee_tree_set_get_type (void) {
5100         static volatile gsize gee_tree_set_type_id__volatile = 0;
5101         if (g_once_init_enter (&gee_tree_set_type_id__volatile)) {
5102                 static const GTypeInfo g_define_type_info = { sizeof (GeeTreeSetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_tree_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeTreeSet), 0, (GInstanceInitFunc) gee_tree_set_instance_init, NULL };
5103                 static const GInterfaceInfo gee_sorted_set_info = { (GInterfaceInitFunc) gee_tree_set_gee_sorted_set_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
5104                 GType gee_tree_set_type_id;
5105                 gee_tree_set_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_SET, "GeeTreeSet", &g_define_type_info, 0);
5106                 g_type_add_interface_static (gee_tree_set_type_id, GEE_TYPE_SORTED_SET, &gee_sorted_set_info);
5107                 g_once_init_leave (&gee_tree_set_type_id__volatile, gee_tree_set_type_id);
5108         }
5109         return gee_tree_set_type_id__volatile;
5110 }
5111
5112
5113 static void _vala_gee_tree_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
5114         GeeTreeSet * self;
5115         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_TREE_SET, GeeTreeSet);
5116         switch (property_id) {
5117                 case GEE_TREE_SET_SIZE:
5118                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
5119                 break;
5120                 case GEE_TREE_SET_COMPARE_FUNC:
5121                 g_value_set_pointer (value, gee_tree_set_get_compare_func (self));
5122                 break;
5123                 default:
5124                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
5125                 break;
5126         }
5127 }
5128
5129
5130 static void _vala_gee_tree_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
5131         GeeTreeSet * self;
5132         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_TREE_SET, GeeTreeSet);
5133         switch (property_id) {
5134                 case GEE_TREE_SET_COMPARE_FUNC:
5135                 gee_tree_set_set_compare_func (self, g_value_get_pointer (value));
5136                 break;
5137                 case GEE_TREE_SET_G_TYPE:
5138                 self->priv->g_type = g_value_get_gtype (value);
5139                 break;
5140                 case GEE_TREE_SET_G_DUP_FUNC:
5141                 self->priv->g_dup_func = g_value_get_pointer (value);
5142                 break;
5143                 case GEE_TREE_SET_G_DESTROY_FUNC:
5144                 self->priv->g_destroy_func = g_value_get_pointer (value);
5145                 break;
5146                 default:
5147                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
5148                 break;
5149         }
5150 }
5151
5152
5153