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