gee/linkedlist.c

   1 /* linkedlist.c generated by valac 0.18.0, the Vala compiler
   2  * generated from linkedlist.vala, do not modify */
   3
   4 /* linkedlist.vala
   5  *
   6  * Copyright (C) 2004-2005  Novell, Inc
   7  * Copyright (C) 2005  David Waite
   8  * Copyright (C) 2007-2008  Jürg Billeter
   9  * Copyright (C) 2009  Mark Lee, Didier Villevalois
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  24  *
  25  * Author:
  26  *      Mark Lee <marklee@src.gnome.org>
  27  *      Didier 'Ptitjes Villevalois <ptitjes@free.fr>
  28  */
  29
  30 #include <glib.h>
  31 #include <glib-object.h>
  32
  33
  34 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  35 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  36 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  37 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  38
  39 typedef struct _GeeTraversable GeeTraversable;
  40 typedef struct _GeeTraversableIface GeeTraversableIface;
  41
  42 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  43
  44 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  45 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  46 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  47 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  48 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  49 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  50
  51 typedef struct _GeeLazy GeeLazy;
  52 typedef struct _GeeLazyClass GeeLazyClass;
  53
  54 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  55 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  56 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  57 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  58
  59 typedef struct _GeeIterator GeeIterator;
  60 typedef struct _GeeIteratorIface GeeIteratorIface;
  61
  62 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  63 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  64 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  65 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  66
  67 typedef struct _GeeIterable GeeIterable;
  68 typedef struct _GeeIterableIface GeeIterableIface;
  69
  70 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  71 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  72 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  73 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  74
  75 typedef struct _GeeCollection GeeCollection;
  76 typedef struct _GeeCollectionIface GeeCollectionIface;
  77
  78 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
  79 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
  80 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  81 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
  82 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
  83 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  84
  85 typedef struct _GeeAbstractCollection GeeAbstractCollection;
  86 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
  87 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
  88
  89 #define GEE_TYPE_LIST (gee_list_get_type ())
  90 #define GEE_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LIST, GeeList))
  91 #define GEE_IS_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LIST))
  92 #define GEE_LIST_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_LIST, GeeListIface))
  93
  94 typedef struct _GeeList GeeList;
  95 typedef struct _GeeListIface GeeListIface;
  96
  97 #define GEE_TYPE_LIST_ITERATOR (gee_list_iterator_get_type ())
  98 #define GEE_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LIST_ITERATOR, GeeListIterator))
  99 #define GEE_IS_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LIST_ITERATOR))
 100 #define GEE_LIST_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_LIST_ITERATOR, GeeListIteratorIface))
 101
 102 typedef struct _GeeListIterator GeeListIterator;
 103 typedef struct _GeeListIteratorIface GeeListIteratorIface;
 104
 105 #define GEE_TYPE_ABSTRACT_LIST (gee_abstract_list_get_type ())
 106 #define GEE_ABSTRACT_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_LIST, GeeAbstractList))
 107 #define GEE_ABSTRACT_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_LIST, GeeAbstractListClass))
 108 #define GEE_IS_ABSTRACT_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_LIST))
 109 #define GEE_IS_ABSTRACT_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_LIST))
 110 #define GEE_ABSTRACT_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_LIST, GeeAbstractListClass))
 111
 112 typedef struct _GeeAbstractList GeeAbstractList;
 113 typedef struct _GeeAbstractListClass GeeAbstractListClass;
 114 typedef struct _GeeAbstractListPrivate GeeAbstractListPrivate;
 115
 116 #define GEE_TYPE_BIDIR_LIST (gee_bidir_list_get_type ())
 117 #define GEE_BIDIR_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_BIDIR_LIST, GeeBidirList))
 118 #define GEE_IS_BIDIR_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_BIDIR_LIST))
 119 #define GEE_BIDIR_LIST_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_BIDIR_LIST, GeeBidirListIface))
 120
 121 typedef struct _GeeBidirList GeeBidirList;
 122 typedef struct _GeeBidirListIface GeeBidirListIface;
 123
 124 #define GEE_TYPE_BIDIR_ITERATOR (gee_bidir_iterator_get_type ())
 125 #define GEE_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIterator))
 126 #define GEE_IS_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_BIDIR_ITERATOR))
 127 #define GEE_BIDIR_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIteratorIface))
 128
 129 typedef struct _GeeBidirIterator GeeBidirIterator;
 130 typedef struct _GeeBidirIteratorIface GeeBidirIteratorIface;
 131
 132 #define GEE_TYPE_BIDIR_LIST_ITERATOR (gee_bidir_list_iterator_get_type ())
 133 #define GEE_BIDIR_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_BIDIR_LIST_ITERATOR, GeeBidirListIterator))
 134 #define GEE_IS_BIDIR_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_BIDIR_LIST_ITERATOR))
 135 #define GEE_BIDIR_LIST_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_BIDIR_LIST_ITERATOR, GeeBidirListIteratorIface))
 136
 137 typedef struct _GeeBidirListIterator GeeBidirListIterator;
 138 typedef struct _GeeBidirListIteratorIface GeeBidirListIteratorIface;
 139
 140 #define GEE_TYPE_ABSTRACT_BIDIR_LIST (gee_abstract_bidir_list_get_type ())
 141 #define GEE_ABSTRACT_BIDIR_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_BIDIR_LIST, GeeAbstractBidirList))
 142 #define GEE_ABSTRACT_BIDIR_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_BIDIR_LIST, GeeAbstractBidirListClass))
 143 #define GEE_IS_ABSTRACT_BIDIR_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_BIDIR_LIST))
 144 #define GEE_IS_ABSTRACT_BIDIR_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_BIDIR_LIST))
 145 #define GEE_ABSTRACT_BIDIR_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_BIDIR_LIST, GeeAbstractBidirListClass))
 146
 147 typedef struct _GeeAbstractBidirList GeeAbstractBidirList;
 148 typedef struct _GeeAbstractBidirListClass GeeAbstractBidirListClass;
 149 typedef struct _GeeAbstractBidirListPrivate GeeAbstractBidirListPrivate;
 150
 151 #define GEE_TYPE_QUEUE (gee_queue_get_type ())
 152 #define GEE_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_QUEUE, GeeQueue))
 153 #define GEE_IS_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_QUEUE))
 154 #define GEE_QUEUE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_QUEUE, GeeQueueIface))
 155
 156 typedef struct _GeeQueue GeeQueue;
 157 typedef struct _GeeQueueIface GeeQueueIface;
 158
 159 #define GEE_TYPE_DEQUE (gee_deque_get_type ())
 160 #define GEE_DEQUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_DEQUE, GeeDeque))
 161 #define GEE_IS_DEQUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_DEQUE))
 162 #define GEE_DEQUE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_DEQUE, GeeDequeIface))
 163
 164 typedef struct _GeeDeque GeeDeque;
 165 typedef struct _GeeDequeIface GeeDequeIface;
 166
 167 #define GEE_TYPE_LINKED_LIST (gee_linked_list_get_type ())
 168 #define GEE_LINKED_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LINKED_LIST, GeeLinkedList))
 169 #define GEE_LINKED_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LINKED_LIST, GeeLinkedListClass))
 170 #define GEE_IS_LINKED_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LINKED_LIST))
 171 #define GEE_IS_LINKED_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LINKED_LIST))
 172 #define GEE_LINKED_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LINKED_LIST, GeeLinkedListClass))
 173
 174 typedef struct _GeeLinkedList GeeLinkedList;
 175 typedef struct _GeeLinkedListClass GeeLinkedListClass;
 176 typedef struct _GeeLinkedListPrivate GeeLinkedListPrivate;
 177 typedef struct _GeeLinkedListNode GeeLinkedListNode;
 178 #define _gee_linked_list_node_free0(var) ((var == NULL) ? NULL : (var = (gee_linked_list_node_free (var), NULL)))
 179
 180 #define GEE_LINKED_LIST_TYPE_ITERATOR (gee_linked_list_iterator_get_type ())
 181 #define GEE_LINKED_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator))
 182 #define GEE_LINKED_LIST_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIteratorClass))
 183 #define GEE_LINKED_LIST_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_LINKED_LIST_TYPE_ITERATOR))
 184 #define GEE_LINKED_LIST_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_LINKED_LIST_TYPE_ITERATOR))
 185 #define GEE_LINKED_LIST_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIteratorClass))
 186
 187 typedef struct _GeeLinkedListIterator GeeLinkedListIterator;
 188 typedef struct _GeeLinkedListIteratorClass GeeLinkedListIteratorClass;
 189 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 190 typedef struct _GeeLinkedListIteratorPrivate GeeLinkedListIteratorPrivate;
 191 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 192
 193 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 194 typedef enum  {
 195         GEE_TRAVERSABLE_STREAM_YIELD,
 196         GEE_TRAVERSABLE_STREAM_CONTINUE,
 197         GEE_TRAVERSABLE_STREAM_END
 198 } GeeTraversableStream;
 199
 200 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 201 struct _GeeIteratorIface {
 202         GTypeInterface parent_iface;
 203         gboolean (*next) (GeeIterator* self);
 204         gboolean (*has_next) (GeeIterator* self);
 205         gpointer (*get) (GeeIterator* self);
 206         void (*remove) (GeeIterator* self);
 207         gboolean (*get_valid) (GeeIterator* self);
 208         gboolean (*get_read_only) (GeeIterator* self);
 209 };
 210
 211 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 212 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 213 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 214 struct _GeeTraversableIface {
 215         GTypeInterface parent_iface;
 216         GType (*get_g_type) (GeeTraversable* self);
 217         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 218         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 219         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 220         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);
 221         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 222         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 223         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 224         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 225         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 226         GType (*get_element_type) (GeeTraversable* self);
 227 };
 228
 229 struct _GeeIterableIface {
 230         GTypeInterface parent_iface;
 231         GType (*get_g_type) (GeeIterable* self);
 232         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 233         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 234         GeeIterator* (*iterator) (GeeIterable* self);
 235 };
 236
 237 struct _GeeCollectionIface {
 238         GTypeInterface parent_iface;
 239         GType (*get_g_type) (GeeCollection* self);
 240         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 241         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 242         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 243         gboolean (*add) (GeeCollection* self, gconstpointer item);
 244         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 245         void (*clear) (GeeCollection* self);
 246         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 247         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 248         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 249         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 250         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 251         gint (*get_size) (GeeCollection* self);
 252         gboolean (*get_is_empty) (GeeCollection* self);
 253         gboolean (*get_read_only) (GeeCollection* self);
 254         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 255 };
 256
 257 struct _GeeAbstractCollection {
 258         GObject parent_instance;
 259         GeeAbstractCollectionPrivate * priv;
 260 };
 261
 262 struct _GeeAbstractCollectionClass {
 263         GObjectClass parent_class;
 264         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 265         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 266         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 267         void (*clear) (GeeAbstractCollection* self);
 268         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 269         gboolean (*foreach) (GeeAbstractCollection* self, GeeForallFunc f, void* f_target);
 270         void (*reserved0) (GeeAbstractCollection* self);
 271         void (*reserved1) (GeeAbstractCollection* self);
 272         void (*reserved2) (GeeAbstractCollection* self);
 273         void (*reserved3) (GeeAbstractCollection* self);
 274         void (*reserved4) (GeeAbstractCollection* self);
 275         void (*reserved5) (GeeAbstractCollection* self);
 276         void (*reserved6) (GeeAbstractCollection* self);
 277         void (*reserved7) (GeeAbstractCollection* self);
 278         void (*reserved8) (GeeAbstractCollection* self);
 279         void (*reserved9) (GeeAbstractCollection* self);
 280         gint (*get_size) (GeeAbstractCollection* self);
 281         gboolean (*get_read_only) (GeeAbstractCollection* self);
 282         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 283 };
 284
 285 struct _GeeListIteratorIface {
 286         GTypeInterface parent_iface;
 287         void (*set) (GeeListIterator* self, gconstpointer item);
 288         void (*add) (GeeListIterator* self, gconstpointer item);
 289         gint (*index) (GeeListIterator* self);
 290 };
 291
 292 struct _GeeListIface {
 293         GTypeInterface parent_iface;
 294         GType (*get_g_type) (GeeList* self);
 295         GBoxedCopyFunc (*get_g_dup_func) (GeeList* self);
 296         GDestroyNotify (*get_g_destroy_func) (GeeList* self);
 297         GeeListIterator* (*list_iterator) (GeeList* self);
 298         gpointer (*get) (GeeList* self, gint index);
 299         void (*set) (GeeList* self, gint index, gconstpointer item);
 300         gint (*index_of) (GeeList* self, gconstpointer item);
 301         void (*insert) (GeeList* self, gint index, gconstpointer item);
 302         gpointer (*remove_at) (GeeList* self, gint index);
 303         GeeList* (*slice) (GeeList* self, gint start, gint stop);
 304         gpointer (*first) (GeeList* self);
 305         gpointer (*last) (GeeList* self);
 306         void (*insert_all) (GeeList* self, gint index, GeeCollection* collection);
 307         void (*sort) (GeeList* self, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify);
 308         GeeList* (*get_read_only_view) (GeeList* self);
 309 };
 310
 311 struct _GeeAbstractList {
 312         GeeAbstractCollection parent_instance;
 313         GeeAbstractListPrivate * priv;
 314 };
 315
 316 struct _GeeAbstractListClass {
 317         GeeAbstractCollectionClass parent_class;
 318         GeeListIterator* (*list_iterator) (GeeAbstractList* self);
 319         gpointer (*get) (GeeAbstractList* self, gint index);
 320         void (*set) (GeeAbstractList* self, gint index, gconstpointer item);
 321         gint (*index_of) (GeeAbstractList* self, gconstpointer item);
 322         void (*insert) (GeeAbstractList* self, gint index, gconstpointer item);
 323         gpointer (*remove_at) (GeeAbstractList* self, gint index);
 324         GeeList* (*slice) (GeeAbstractList* self, gint start, gint stop);
 325         void (*reserved0) (GeeAbstractList* self);
 326         void (*reserved1) (GeeAbstractList* self);
 327         void (*reserved2) (GeeAbstractList* self);
 328         void (*reserved3) (GeeAbstractList* self);
 329         void (*reserved4) (GeeAbstractList* self);
 330         void (*reserved5) (GeeAbstractList* self);
 331         void (*reserved6) (GeeAbstractList* self);
 332         void (*reserved7) (GeeAbstractList* self);
 333         void (*reserved8) (GeeAbstractList* self);
 334         void (*reserved9) (GeeAbstractList* self);
 335         GeeList* (*get_read_only_view) (GeeAbstractList* self);
 336 };
 337
 338 struct _GeeBidirIteratorIface {
 339         GTypeInterface parent_iface;
 340         GType (*get_g_type) (GeeBidirIterator* self);
 341         GBoxedCopyFunc (*get_g_dup_func) (GeeBidirIterator* self);
 342         GDestroyNotify (*get_g_destroy_func) (GeeBidirIterator* self);
 343         gboolean (*previous) (GeeBidirIterator* self);
 344         gboolean (*has_previous) (GeeBidirIterator* self);
 345         gboolean (*first) (GeeBidirIterator* self);
 346         gboolean (*last) (GeeBidirIterator* self);
 347 };
 348
 349 struct _GeeBidirListIteratorIface {
 350         GTypeInterface parent_iface;
 351         GType (*get_g_type) (GeeBidirListIterator* self);
 352         GBoxedCopyFunc (*get_g_dup_func) (GeeBidirListIterator* self);
 353         GDestroyNotify (*get_g_destroy_func) (GeeBidirListIterator* self);
 354         void (*insert) (GeeBidirListIterator* self, gconstpointer item);
 355 };
 356
 357 struct _GeeBidirListIface {
 358         GTypeInterface parent_iface;
 359         GType (*get_g_type) (GeeBidirList* self);
 360         GBoxedCopyFunc (*get_g_dup_func) (GeeBidirList* self);
 361         GDestroyNotify (*get_g_destroy_func) (GeeBidirList* self);
 362         GeeBidirListIterator* (*bidir_list_iterator) (GeeBidirList* self);
 363         GeeBidirList* (*get_read_only_view) (GeeBidirList* self);
 364 };
 365
 366 struct _GeeAbstractBidirList {
 367         GeeAbstractList parent_instance;
 368         GeeAbstractBidirListPrivate * priv;
 369 };
 370
 371 struct _GeeAbstractBidirListClass {
 372         GeeAbstractListClass parent_class;
 373         GeeBidirListIterator* (*bidir_list_iterator) (GeeAbstractBidirList* self);
 374         void (*reserved0) (GeeAbstractBidirList* self);
 375         void (*reserved1) (GeeAbstractBidirList* self);
 376         void (*reserved2) (GeeAbstractBidirList* self);
 377         void (*reserved3) (GeeAbstractBidirList* self);
 378         void (*reserved4) (GeeAbstractBidirList* self);
 379         void (*reserved5) (GeeAbstractBidirList* self);
 380         void (*reserved6) (GeeAbstractBidirList* self);
 381         void (*reserved7) (GeeAbstractBidirList* self);
 382         void (*reserved8) (GeeAbstractBidirList* self);
 383         void (*reserved9) (GeeAbstractBidirList* self);
 384         GeeBidirList* (*get_read_only_view) (GeeAbstractBidirList* self);
 385 };
 386
 387 struct _GeeQueueIface {
 388         GTypeInterface parent_iface;
 389         GType (*get_g_type) (GeeQueue* self);
 390         GBoxedCopyFunc (*get_g_dup_func) (GeeQueue* self);
 391         GDestroyNotify (*get_g_destroy_func) (GeeQueue* self);
 392         gboolean (*offer) (GeeQueue* self, gconstpointer element);
 393         gpointer (*peek) (GeeQueue* self);
 394         gpointer (*poll) (GeeQueue* self);
 395         gint (*drain) (GeeQueue* self, GeeCollection* recipient, gint amount);
 396         gint (*get_capacity) (GeeQueue* self);
 397         gint (*get_remaining_capacity) (GeeQueue* self);
 398         gboolean (*get_is_full) (GeeQueue* self);
 399 };
 400
 401 struct _GeeDequeIface {
 402         GTypeInterface parent_iface;
 403         GType (*get_g_type) (GeeDeque* self);
 404         GBoxedCopyFunc (*get_g_dup_func) (GeeDeque* self);
 405         GDestroyNotify (*get_g_destroy_func) (GeeDeque* self);
 406         gboolean (*offer_head) (GeeDeque* self, gconstpointer element);
 407         gpointer (*peek_head) (GeeDeque* self);
 408         gpointer (*poll_head) (GeeDeque* self);
 409         gint (*drain_head) (GeeDeque* self, GeeCollection* recipient, gint amount);
 410         gboolean (*offer_tail) (GeeDeque* self, gconstpointer element);
 411         gpointer (*peek_tail) (GeeDeque* self);
 412         gpointer (*poll_tail) (GeeDeque* self);
 413         gint (*drain_tail) (GeeDeque* self, GeeCollection* recipient, gint amount);
 414 };
 415
 416 struct _GeeLinkedList {
 417         GeeAbstractBidirList parent_instance;
 418         GeeLinkedListPrivate * priv;
 419 };
 420
 421 struct _GeeLinkedListClass {
 422         GeeAbstractBidirListClass parent_class;
 423 };
 424
 425 typedef gboolean (*GeeEqualDataFunc) (gconstpointer a, gconstpointer b, void* user_data);
 426 struct _GeeLinkedListPrivate {
 427         GType g_type;
 428         GBoxedCopyFunc g_dup_func;
 429         GDestroyNotify g_destroy_func;
 430         gint _size;
 431         gint _stamp;
 432         GeeLinkedListNode* _head;
 433         GeeLinkedListNode* _tail;
 434         GeeEqualDataFunc _equal_func;
 435         gpointer _equal_func_target;
 436         GDestroyNotify _equal_func_target_destroy_notify;
 437 };
 438
 439 struct _GeeLinkedListNode {
 440         gpointer data;
 441         GeeLinkedListNode* prev;
 442         GeeLinkedListNode* next;
 443 };
 444
 445 struct _GeeLinkedListIterator {
 446         GObject parent_instance;
 447         GeeLinkedListIteratorPrivate * priv;
 448 };
 449
 450 struct _GeeLinkedListIteratorClass {
 451         GObjectClass parent_class;
 452 };
 453
 454 struct _GeeLinkedListIteratorPrivate {
 455         GType g_type;
 456         GBoxedCopyFunc g_dup_func;
 457         GDestroyNotify g_destroy_func;
 458         gboolean started;
 459         gboolean removed;
 460         GeeLinkedListNode* position;
 461         gint _stamp;
 462         GeeLinkedList* _list;
 463         gint _index;
 464 };
 465
 466
 467 static gpointer gee_linked_list_parent_class = NULL;
 468 static gpointer gee_linked_list_iterator_parent_class = NULL;
 469 static GeeTraversableIface* gee_linked_list_iterator_gee_traversable_parent_iface = NULL;
 470 static GeeIteratorIface* gee_linked_list_iterator_gee_iterator_parent_iface = NULL;
 471 static GeeBidirIteratorIface* gee_linked_list_iterator_gee_bidir_iterator_parent_iface = NULL;
 472 static GeeListIteratorIface* gee_linked_list_iterator_gee_list_iterator_parent_iface = NULL;
 473 static GeeBidirListIteratorIface* gee_linked_list_iterator_gee_bidir_list_iterator_parent_iface = NULL;
 474 static GeeQueueIface* gee_linked_list_gee_queue_parent_iface = NULL;
 475 static GeeDequeIface* gee_linked_list_gee_deque_parent_iface = NULL;
 476
 477 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 478 gpointer gee_lazy_ref (gpointer instance);
 479 void gee_lazy_unref (gpointer instance);
 480 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 481 void gee_value_set_lazy (GValue* value, gpointer v_object);
 482 void gee_value_take_lazy (GValue* value, gpointer v_object);
 483 gpointer gee_value_get_lazy (const GValue* value);
 484 GType gee_lazy_get_type (void) G_GNUC_CONST;
 485 GType gee_iterator_get_type (void) G_GNUC_CONST;
 486 GType gee_traversable_get_type (void) G_GNUC_CONST;
 487 GType gee_iterable_get_type (void) G_GNUC_CONST;
 488 GType gee_collection_get_type (void) G_GNUC_CONST;
 489 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 490 GType gee_list_iterator_get_type (void) G_GNUC_CONST;
 491 GType gee_list_get_type (void) G_GNUC_CONST;
 492 GType gee_abstract_list_get_type (void) G_GNUC_CONST;
 493 GType gee_bidir_iterator_get_type (void) G_GNUC_CONST;
 494 GType gee_bidir_list_iterator_get_type (void) G_GNUC_CONST;
 495 GType gee_bidir_list_get_type (void) G_GNUC_CONST;
 496 GType gee_abstract_bidir_list_get_type (void) G_GNUC_CONST;
 497 GType gee_queue_get_type (void) G_GNUC_CONST;
 498 GType gee_deque_get_type (void) G_GNUC_CONST;
 499 GType gee_linked_list_get_type (void) G_GNUC_CONST;
 500 static void gee_linked_list_node_free (GeeLinkedListNode* self);
 501 #define GEE_LINKED_LIST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_LINKED_LIST, GeeLinkedListPrivate))
 502 enum  {
 503         GEE_LINKED_LIST_DUMMY_PROPERTY,
 504         GEE_LINKED_LIST_G_TYPE,
 505         GEE_LINKED_LIST_G_DUP_FUNC,
 506         GEE_LINKED_LIST_G_DESTROY_FUNC,
 507         GEE_LINKED_LIST_SIZE,
 508         GEE_LINKED_LIST_READ_ONLY,
 509         GEE_LINKED_LIST_CAPACITY,
 510         GEE_LINKED_LIST_REMAINING_CAPACITY,
 511         GEE_LINKED_LIST_IS_FULL
 512 };
 513 void gee_abstract_collection_clear (GeeAbstractCollection* self);
 514 GeeLinkedList* gee_linked_list_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeEqualDataFunc equal_func, void* equal_func_target, GDestroyNotify equal_func_target_destroy_notify);
 515 GeeLinkedList* gee_linked_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeEqualDataFunc equal_func, void* equal_func_target, GDestroyNotify equal_func_target_destroy_notify);
 516 GeeAbstractBidirList* gee_abstract_bidir_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 517 GeeEqualDataFunc gee_functions_get_equal_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
 518 static void gee_linked_list_set_equal_func (GeeLinkedList* self, GeeEqualDataFunc value, gpointer value_target);
 519 static gboolean gee_linked_list_real_foreach (GeeAbstractCollection* base, GeeForallFunc f, void* f_target);
 520 static GeeIterator* gee_linked_list_real_iterator (GeeAbstractCollection* base);
 521 static GeeLinkedListIterator* gee_linked_list_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list);
 522 static GeeLinkedListIterator* gee_linked_list_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list);
 523 static GType gee_linked_list_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 524 static GeeListIterator* gee_linked_list_real_list_iterator (GeeAbstractList* base);
 525 static GeeBidirListIterator* gee_linked_list_real_bidir_list_iterator (GeeAbstractBidirList* base);
 526 static gboolean gee_linked_list_real_contains (GeeAbstractCollection* base, gconstpointer item);
 527 gint gee_abstract_list_index_of (GeeAbstractList* self, gconstpointer item);
 528 static gboolean gee_linked_list_real_add (GeeAbstractCollection* base, gconstpointer item);
 529 static GeeLinkedListNode* gee_linked_list_node_new (gpointer data);
 530 static GeeLinkedListNode* gee_linked_list_node_new (gpointer data);
 531 static gboolean gee_linked_list_real_remove (GeeAbstractCollection* base, gconstpointer item);
 532 GeeEqualDataFunc gee_linked_list_get_equal_func (GeeLinkedList* self, gpointer* result_target);
 533 static void _gee_linked_list_remove_node (GeeLinkedList* self, GeeLinkedListNode* _n);
 534 static void gee_linked_list_real_clear (GeeAbstractCollection* base);
 535 static gpointer gee_linked_list_real_get (GeeAbstractList* base, gint index);
 536 static GeeLinkedListNode* _gee_linked_list_get_node_at (GeeLinkedList* self, gint index);
 537 static void gee_linked_list_real_set (GeeAbstractList* base, gint index, gconstpointer item);
 538 static gint gee_linked_list_real_index_of (GeeAbstractList* base, gconstpointer item);
 539 static void gee_linked_list_real_insert (GeeAbstractList* base, gint index, gconstpointer item);
 540 gboolean gee_abstract_collection_add (GeeAbstractCollection* self, gconstpointer item);
 541 static gpointer gee_linked_list_real_remove_at (GeeAbstractList* base, gint index);
 542 static GeeList* gee_linked_list_real_slice (GeeAbstractList* base, gint start, gint stop);
 543 gboolean gee_collection_add (GeeCollection* self, gconstpointer item);
 544 gpointer gee_linked_list_first (GeeLinkedList* self);
 545 gpointer gee_linked_list_last (GeeLinkedList* self);
 546 static gboolean gee_linked_list_real_offer (GeeQueue* base, gconstpointer element);
 547 gboolean gee_deque_offer_tail (GeeDeque* self, gconstpointer element);
 548 static gpointer gee_linked_list_real_peek (GeeQueue* base);
 549 gpointer gee_deque_peek_head (GeeDeque* self);
 550 static gpointer gee_linked_list_real_poll (GeeQueue* base);
 551 gpointer gee_deque_poll_head (GeeDeque* self);
 552 static gint gee_linked_list_real_drain (GeeQueue* base, GeeCollection* recipient, gint amount);
 553 gint gee_deque_drain_head (GeeDeque* self, GeeCollection* recipient, gint amount);
 554 static gboolean gee_linked_list_real_offer_head (GeeDeque* base, gconstpointer element);
 555 void gee_abstract_list_insert (GeeAbstractList* self, gint index, gconstpointer item);
 556 static gpointer gee_linked_list_real_peek_head (GeeDeque* base);
 557 gpointer gee_abstract_list_get (GeeAbstractList* self, gint index);
 558 static gpointer gee_linked_list_real_poll_head (GeeDeque* base);
 559 gpointer gee_abstract_list_remove_at (GeeAbstractList* self, gint index);
 560 static gint gee_linked_list_real_drain_head (GeeDeque* base, GeeCollection* recipient, gint amount);
 561 static gboolean gee_linked_list_real_offer_tail (GeeDeque* base, gconstpointer element);
 562 static gpointer gee_linked_list_real_peek_tail (GeeDeque* base);
 563 static gpointer gee_linked_list_real_poll_tail (GeeDeque* base);
 564 static gint gee_linked_list_real_drain_tail (GeeDeque* base, GeeCollection* recipient, gint amount);
 565 #define GEE_QUEUE_UNBOUNDED_CAPACITY (-1)
 566 static void gee_linked_list_node_instance_init (GeeLinkedListNode * self);
 567 #define GEE_LINKED_LIST_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIteratorPrivate))
 568 enum  {
 569         GEE_LINKED_LIST_ITERATOR_DUMMY_PROPERTY,
 570         GEE_LINKED_LIST_ITERATOR_G_TYPE,
 571         GEE_LINKED_LIST_ITERATOR_G_DUP_FUNC,
 572         GEE_LINKED_LIST_ITERATOR_G_DESTROY_FUNC,
 573         GEE_LINKED_LIST_ITERATOR_READ_ONLY,
 574         GEE_LINKED_LIST_ITERATOR_VALID
 575 };
 576 static gboolean gee_linked_list_iterator_real_next (GeeIterator* base);
 577 static gboolean gee_linked_list_iterator_real_has_next (GeeIterator* base);
 578 static gboolean gee_linked_list_iterator_real_first (GeeBidirIterator* base);
 579 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 580 static gpointer gee_linked_list_iterator_real_get (GeeIterator* base);
 581 static void gee_linked_list_iterator_real_remove (GeeIterator* base);
 582 static gboolean gee_linked_list_iterator_real_previous (GeeBidirIterator* base);
 583 static gboolean gee_linked_list_iterator_real_has_previous (GeeBidirIterator* base);
 584 static gboolean gee_linked_list_iterator_real_last (GeeBidirIterator* base);
 585 static void gee_linked_list_iterator_real_set (GeeListIterator* base, gconstpointer item);
 586 static void gee_linked_list_iterator_real_insert (GeeBidirListIterator* base, gconstpointer item);
 587 static void gee_linked_list_iterator_real_add (GeeListIterator* base, gconstpointer item);
 588 static gint gee_linked_list_iterator_real_index (GeeListIterator* base);
 589 static gboolean gee_linked_list_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 590 static void gee_linked_list_iterator_finalize (GObject* obj);
 591 gboolean gee_iterator_get_read_only (GeeIterator* self);
 592 gboolean gee_iterator_get_valid (GeeIterator* self);
 593 static void _vala_gee_linked_list_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 594 static void _vala_gee_linked_list_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 595 static void gee_linked_list_finalize (GObject* obj);
 596 gboolean gee_abstract_collection_get_read_only (GeeAbstractCollection* self);
 597 gint gee_queue_get_capacity (GeeQueue* self);
 598 gint gee_queue_get_remaining_capacity (GeeQueue* self);
 599 gboolean gee_queue_get_is_full (GeeQueue* self);
 600 static void _vala_gee_linked_list_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 601 static void _vala_gee_linked_list_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 602
 603
 604 /**
 605  * Constructs a new, empty linked list.
 606  *
 607  * If not provided, the function parameter is requested to the
 608  * {@link Functions} function factory methods.
 609  *
 610  * @param equal_func an optional element equality testing function
 611  */
 612 GeeLinkedList* gee_linked_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeEqualDataFunc equal_func, void* equal_func_target, GDestroyNotify equal_func_target_destroy_notify) {
 613         GeeLinkedList * self = NULL;
 614         GeeEqualDataFunc _tmp0_;
 615         void* _tmp0__target;
 616         GeeEqualDataFunc _tmp4_;
 617         void* _tmp4__target;
 618         self = (GeeLinkedList*) gee_abstract_bidir_list_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
 619         self->priv->g_type = g_type;
 620         self->priv->g_dup_func = g_dup_func;
 621         self->priv->g_destroy_func = g_destroy_func;
 622         _tmp0_ = equal_func;
 623         _tmp0__target = equal_func_target;
 624         if (_tmp0_ == NULL) {
 625                 void* _tmp1_ = NULL;
 626                 GDestroyNotify _tmp2_ = NULL;
 627                 GeeEqualDataFunc _tmp3_ = NULL;
 628                 _tmp3_ = gee_functions_get_equal_func_for (g_type, &_tmp1_, &_tmp2_);
 629                 (equal_func_target_destroy_notify == NULL) ? NULL : (equal_func_target_destroy_notify (equal_func_target), NULL);
 630                 equal_func = NULL;
 631                 equal_func_target = NULL;
 632                 equal_func_target_destroy_notify = NULL;
 633                 equal_func = _tmp3_;
 634                 equal_func_target = _tmp1_;
 635                 equal_func_target_destroy_notify = _tmp2_;
 636         }
 637         _tmp4_ = equal_func;
 638         _tmp4__target = equal_func_target;
 639         gee_linked_list_set_equal_func (self, _tmp4_, _tmp4__target);
 640         (equal_func_target_destroy_notify == NULL) ? NULL : (equal_func_target_destroy_notify (equal_func_target), NULL);
 641         equal_func = NULL;
 642         equal_func_target = NULL;
 643         equal_func_target_destroy_notify = NULL;
 644         return self;
 645 }
 646
 647
 648 GeeLinkedList* gee_linked_list_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeEqualDataFunc equal_func, void* equal_func_target, GDestroyNotify equal_func_target_destroy_notify) {
 649         return gee_linked_list_construct (GEE_TYPE_LINKED_LIST, g_type, g_dup_func, g_destroy_func, equal_func, equal_func_target, equal_func_target_destroy_notify);
 650 }
 651
 652
 653 /**
 654  * {@inheritDoc}
 655  */
 656 static gboolean gee_linked_list_real_foreach (GeeAbstractCollection* base, GeeForallFunc f, void* f_target) {
 657         GeeLinkedList * self;
 658         gboolean result = FALSE;
 659         self = (GeeLinkedList*) base;
 660         {
 661                 GeeLinkedListNode* _tmp0_;
 662                 GeeLinkedListNode* node;
 663                 _tmp0_ = self->priv->_head;
 664                 node = _tmp0_;
 665                 {
 666                         gboolean _tmp1_;
 667                         _tmp1_ = TRUE;
 668                         while (TRUE) {
 669                                 gboolean _tmp2_;
 670                                 GeeLinkedListNode* _tmp5_;
 671                                 GeeForallFunc _tmp6_;
 672                                 void* _tmp6__target;
 673                                 GeeLinkedListNode* _tmp7_;
 674                                 gconstpointer _tmp8_;
 675                                 gpointer _tmp9_;
 676                                 gboolean _tmp10_ = FALSE;
 677                                 _tmp2_ = _tmp1_;
 678                                 if (!_tmp2_) {
 679                                         GeeLinkedListNode* _tmp3_;
 680                                         GeeLinkedListNode* _tmp4_;
 681                                         _tmp3_ = node;
 682                                         _tmp4_ = _tmp3_->next;
 683                                         node = _tmp4_;
 684                                 }
 685                                 _tmp1_ = FALSE;
 686                                 _tmp5_ = node;
 687                                 if (!(_tmp5_ != NULL)) {
 688                                         break;
 689                                 }
 690                                 _tmp6_ = f;
 691                                 _tmp6__target = f_target;
 692                                 _tmp7_ = node;
 693                                 _tmp8_ = _tmp7_->data;
 694                                 _tmp9_ = ((_tmp8_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
 695                                 _tmp10_ = _tmp6_ (_tmp9_, _tmp6__target);
 696                                 if (!_tmp10_) {
 697                                         result = FALSE;
 698                                         return result;
 699                                 }
 700                         }
 701                 }
 702         }
 703         result = TRUE;
 704         return result;
 705 }
 706
 707
 708 /**
 709  * {@inheritDoc}
 710  */
 711 static GeeIterator* gee_linked_list_real_iterator (GeeAbstractCollection* base) {
 712         GeeLinkedList * self;
 713         GeeIterator* result = NULL;
 714         GeeLinkedListIterator* _tmp0_;
 715         self = (GeeLinkedList*) base;
 716         _tmp0_ = gee_linked_list_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
 717         result = (GeeIterator*) _tmp0_;
 718         return result;
 719 }
 720
 721
 722 /**
 723  * {@inheritDoc}
 724  */
 725 static GeeListIterator* gee_linked_list_real_list_iterator (GeeAbstractList* base) {
 726         GeeLinkedList * self;
 727         GeeListIterator* result = NULL;
 728         GeeLinkedListIterator* _tmp0_;
 729         self = (GeeLinkedList*) base;
 730         _tmp0_ = gee_linked_list_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
 731         result = (GeeListIterator*) _tmp0_;
 732         return result;
 733 }
 734
 735
 736 /**
 737  * {@inheritDoc}
 738  */
 739 static GeeBidirListIterator* gee_linked_list_real_bidir_list_iterator (GeeAbstractBidirList* base) {
 740         GeeLinkedList * self;
 741         GeeBidirListIterator* result = NULL;
 742         GeeLinkedListIterator* _tmp0_;
 743         self = (GeeLinkedList*) base;
 744         _tmp0_ = gee_linked_list_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
 745         result = (GeeBidirListIterator*) _tmp0_;
 746         return result;
 747 }
 748
 749
 750 /**
 751  * {@inheritDoc}
 752  */
 753 static gboolean gee_linked_list_real_contains (GeeAbstractCollection* base, gconstpointer item) {
 754         GeeLinkedList * self;
 755         gboolean result = FALSE;
 756         gconstpointer _tmp0_;
 757         gint _tmp1_ = 0;
 758         self = (GeeLinkedList*) base;
 759         _tmp0_ = item;
 760         _tmp1_ = gee_abstract_list_index_of ((GeeAbstractList*) self, _tmp0_);
 761         result = _tmp1_ != (-1);
 762         return result;
 763 }
 764
 765
 766 /**
 767  * {@inheritDoc}
 768  */
 769 static gboolean gee_linked_list_real_add (GeeAbstractCollection* base, gconstpointer item) {
 770         GeeLinkedList * self;
 771         gboolean result = FALSE;
 772         gconstpointer _tmp0_;
 773         gpointer _tmp1_;
 774         GeeLinkedListNode* _tmp2_;
 775         GeeLinkedListNode* n;
 776         gboolean _tmp3_ = FALSE;
 777         GeeLinkedListNode* _tmp4_;
 778         gboolean _tmp6_;
 779         gint _tmp15_;
 780         self = (GeeLinkedList*) base;
 781         _tmp0_ = item;
 782         _tmp1_ = ((_tmp0_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
 783         _tmp2_ = gee_linked_list_node_new (_tmp1_);
 784         n = _tmp2_;
 785         _tmp4_ = self->priv->_head;
 786         if (_tmp4_ == NULL) {
 787                 GeeLinkedListNode* _tmp5_;
 788                 _tmp5_ = self->priv->_tail;
 789                 _tmp3_ = _tmp5_ == NULL;
 790         } else {
 791                 _tmp3_ = FALSE;
 792         }
 793         _tmp6_ = _tmp3_;
 794         if (_tmp6_) {
 795                 GeeLinkedListNode* _tmp7_;
 796                 GeeLinkedListNode* _tmp8_;
 797                 _tmp7_ = n;
 798                 self->priv->_tail = _tmp7_;
 799                 _tmp8_ = n;
 800                 n = NULL;
 801                 _gee_linked_list_node_free0 (self->priv->_head);
 802                 self->priv->_head = _tmp8_;
 803         } else {
 804                 GeeLinkedListNode* _tmp9_;
 805                 GeeLinkedListNode* _tmp10_;
 806                 GeeLinkedListNode* _tmp11_;
 807                 GeeLinkedListNode* _tmp12_;
 808                 GeeLinkedListNode* _tmp13_;
 809                 GeeLinkedListNode* _tmp14_;
 810                 _tmp9_ = n;
 811                 _tmp10_ = self->priv->_tail;
 812                 _tmp9_->prev = _tmp10_;
 813                 _tmp11_ = self->priv->_tail;
 814                 _tmp12_ = n;
 815                 n = NULL;
 816                 _gee_linked_list_node_free0 (_tmp11_->next);
 817                 _tmp11_->next = _tmp12_;
 818                 _tmp13_ = self->priv->_tail;
 819                 _tmp14_ = _tmp13_->next;
 820                 self->priv->_tail = _tmp14_;
 821         }
 822         _tmp15_ = self->priv->_size;
 823         self->priv->_size = _tmp15_ + 1;
 824         result = TRUE;
 825         _gee_linked_list_node_free0 (n);
 826         return result;
 827 }
 828
 829
 830 /**
 831  * {@inheritDoc}
 832  */
 833 static gboolean gee_linked_list_real_remove (GeeAbstractCollection* base, gconstpointer item) {
 834         GeeLinkedList * self;
 835         gboolean result = FALSE;
 836         self = (GeeLinkedList*) base;
 837         {
 838                 GeeLinkedListNode* _tmp0_;
 839                 GeeLinkedListNode* n;
 840                 _tmp0_ = self->priv->_head;
 841                 n = _tmp0_;
 842                 {
 843                         gboolean _tmp1_;
 844                         _tmp1_ = TRUE;
 845                         while (TRUE) {
 846                                 gboolean _tmp2_;
 847                                 GeeLinkedListNode* _tmp5_;
 848                                 GeeEqualDataFunc _tmp6_;
 849                                 void* _tmp6__target;
 850                                 GeeEqualDataFunc _tmp7_;
 851                                 void* _tmp7__target;
 852                                 gconstpointer _tmp8_;
 853                                 GeeLinkedListNode* _tmp9_;
 854                                 gconstpointer _tmp10_;
 855                                 gboolean _tmp11_ = FALSE;
 856                                 _tmp2_ = _tmp1_;
 857                                 if (!_tmp2_) {
 858                                         GeeLinkedListNode* _tmp3_;
 859                                         GeeLinkedListNode* _tmp4_;
 860                                         _tmp3_ = n;
 861                                         _tmp4_ = _tmp3_->next;
 862                                         n = _tmp4_;
 863                                 }
 864                                 _tmp1_ = FALSE;
 865                                 _tmp5_ = n;
 866                                 if (!(_tmp5_ != NULL)) {
 867                                         break;
 868                                 }
 869                                 _tmp6_ = gee_linked_list_get_equal_func (self, &_tmp6__target);
 870                                 _tmp7_ = _tmp6_;
 871                                 _tmp7__target = _tmp6__target;
 872                                 _tmp8_ = item;
 873                                 _tmp9_ = n;
 874                                 _tmp10_ = _tmp9_->data;
 875                                 _tmp11_ = _tmp7_ (_tmp8_, _tmp10_, _tmp7__target);
 876                                 if (_tmp11_) {
 877                                         GeeLinkedListNode* _tmp12_;
 878                                         _tmp12_ = n;
 879                                         _gee_linked_list_remove_node (self, _tmp12_);
 880                                         result = TRUE;
 881                                         return result;
 882                                 }
 883                         }
 884                 }
 885         }
 886         result = FALSE;
 887         return result;
 888 }
 889
 890
 891 /**
 892  * {@inheritDoc}
 893  */
 894 static void gee_linked_list_real_clear (GeeAbstractCollection* base) {
 895         GeeLinkedList * self;
 896         gint _tmp2_;
 897         self = (GeeLinkedList*) base;
 898         while (TRUE) {
 899                 GeeLinkedListNode* _tmp0_;
 900                 GeeLinkedListNode* _tmp1_;
 901                 _tmp0_ = self->priv->_head;
 902                 if (!(_tmp0_ != NULL)) {
 903                         break;
 904                 }
 905                 _tmp1_ = self->priv->_head;
 906                 _gee_linked_list_remove_node (self, _tmp1_);
 907         }
 908         _tmp2_ = self->priv->_stamp;
 909         self->priv->_stamp = _tmp2_ + 1;
 910         _gee_linked_list_node_free0 (self->priv->_head);
 911         self->priv->_head = NULL;
 912         self->priv->_tail = NULL;
 913         self->priv->_size = 0;
 914 }
 915
 916
 917 /**
 918  * {@inheritDoc}
 919  */
 920 static gpointer gee_linked_list_real_get (GeeAbstractList* base, gint index) {
 921         GeeLinkedList * self;
 922         gpointer result = NULL;
 923         gint _tmp0_;
 924         gint _tmp1_;
 925         gint _tmp2_;
 926         gint _tmp3_;
 927         GeeLinkedListNode* _tmp4_ = NULL;
 928         GeeLinkedListNode* n;
 929         gconstpointer _tmp5_;
 930         gpointer _tmp6_;
 931         self = (GeeLinkedList*) base;
 932         _tmp0_ = index;
 933         _vala_assert (_tmp0_ >= 0, "index >= 0");
 934         _tmp1_ = index;
 935         _tmp2_ = self->priv->_size;
 936         _vala_assert (_tmp1_ < _tmp2_, "index < this._size");
 937         _tmp3_ = index;
 938         _tmp4_ = _gee_linked_list_get_node_at (self, _tmp3_);
 939         n = _tmp4_;
 940         _vala_assert (n != NULL, "n != null");
 941         _tmp5_ = n->data;
 942         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
 943         result = _tmp6_;
 944         return result;
 945 }
 946
 947
 948 /**
 949  * {@inheritDoc}
 950  */
 951 static void gee_linked_list_real_set (GeeAbstractList* base, gint index, gconstpointer item) {
 952         GeeLinkedList * self;
 953         gint _tmp0_;
 954         gint _tmp1_;
 955         gint _tmp2_;
 956         gint _tmp3_;
 957         GeeLinkedListNode* _tmp4_ = NULL;
 958         GeeLinkedListNode* n;
 959         gconstpointer _tmp5_;
 960         gpointer _tmp6_;
 961         self = (GeeLinkedList*) base;
 962         _tmp0_ = index;
 963         _vala_assert (_tmp0_ >= 0, "index >= 0");
 964         _tmp1_ = index;
 965         _tmp2_ = self->priv->_size;
 966         _vala_assert (_tmp1_ < _tmp2_, "index < this._size");
 967         _tmp3_ = index;
 968         _tmp4_ = _gee_linked_list_get_node_at (self, _tmp3_);
 969         n = _tmp4_;
 970         g_return_if_fail (n != NULL);
 971         _tmp5_ = item;
 972         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
 973         ((n->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (n->data = (self->priv->g_destroy_func (n->data), NULL));
 974         n->data = _tmp6_;
 975 }
 976
 977
 978 /**
 979  * {@inheritDoc}
 980  */
 981 static gint gee_linked_list_real_index_of (GeeAbstractList* base, gconstpointer item) {
 982         GeeLinkedList * self;
 983         gint result = 0;
 984         gint idx;
 985         self = (GeeLinkedList*) base;
 986         idx = 0;
 987         {
 988                 GeeLinkedListNode* _tmp0_;
 989                 GeeLinkedListNode* node;
 990                 _tmp0_ = self->priv->_head;
 991                 node = _tmp0_;
 992                 {
 993                         gboolean _tmp1_;
 994                         _tmp1_ = TRUE;
 995                         while (TRUE) {
 996                                 gboolean _tmp2_;
 997                                 GeeLinkedListNode* _tmp6_;
 998                                 GeeEqualDataFunc _tmp7_;
 999                                 void* _tmp7__target;
1000                                 GeeEqualDataFunc _tmp8_;
1001                                 void* _tmp8__target;
1002                                 gconstpointer _tmp9_;
1003                                 GeeLinkedListNode* _tmp10_;
1004                                 gconstpointer _tmp11_;
1005                                 gboolean _tmp12_ = FALSE;
1006                                 _tmp2_ = _tmp1_;
1007                                 if (!_tmp2_) {
1008                                         GeeLinkedListNode* _tmp3_;
1009                                         GeeLinkedListNode* _tmp4_;
1010                                         gint _tmp5_;
1011                                         _tmp3_ = node;
1012                                         _tmp4_ = _tmp3_->next;
1013                                         node = _tmp4_;
1014                                         _tmp5_ = idx;
1015                                         idx = _tmp5_ + 1;
1016                                 }
1017                                 _tmp1_ = FALSE;
1018                                 _tmp6_ = node;
1019                                 if (!(_tmp6_ != NULL)) {
1020                                         break;
1021                                 }
1022                                 _tmp7_ = gee_linked_list_get_equal_func (self, &_tmp7__target);
1023                                 _tmp8_ = _tmp7_;
1024                                 _tmp8__target = _tmp7__target;
1025                                 _tmp9_ = item;
1026                                 _tmp10_ = node;
1027                                 _tmp11_ = _tmp10_->data;
1028                                 _tmp12_ = _tmp8_ (_tmp9_, _tmp11_, _tmp8__target);
1029                                 if (_tmp12_) {
1030                                         result = idx;
1031                                         return result;
1032                                 }
1033                         }
1034                 }
1035         }
1036         result = -1;
1037         return result;
1038 }
1039
1040
1041 /**
1042  * {@inheritDoc}
1043  */
1044 static void gee_linked_list_real_insert (GeeAbstractList* base, gint index, gconstpointer item) {
1045         GeeLinkedList * self;
1046         gint _tmp0_;
1047         gint _tmp1_;
1048         gint _tmp2_;
1049         gint _tmp3_;
1050         gint _tmp4_;
1051         self = (GeeLinkedList*) base;
1052         _tmp0_ = index;
1053         _vala_assert (_tmp0_ >= 0, "index >= 0");
1054         _tmp1_ = index;
1055         _tmp2_ = self->priv->_size;
1056         _vala_assert (_tmp1_ <= _tmp2_, "index <= this._size");
1057         _tmp3_ = index;
1058         _tmp4_ = self->priv->_size;
1059         if (_tmp3_ == _tmp4_) {
1060                 gconstpointer _tmp5_;
1061                 _tmp5_ = item;
1062                 gee_abstract_collection_add ((GeeAbstractCollection*) self, _tmp5_);
1063         } else {
1064                 gconstpointer _tmp6_;
1065                 gpointer _tmp7_;
1066                 GeeLinkedListNode* _tmp8_;
1067                 GeeLinkedListNode* n;
1068                 gint _tmp9_;
1069                 gint _tmp34_;
1070                 _tmp6_ = item;
1071                 _tmp7_ = ((_tmp6_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp6_) : ((gpointer) _tmp6_);
1072                 _tmp8_ = gee_linked_list_node_new (_tmp7_);
1073                 n = _tmp8_;
1074                 _tmp9_ = index;
1075                 if (_tmp9_ == 0) {
1076                         GeeLinkedListNode* _tmp10_;
1077                         GeeLinkedListNode* _tmp11_;
1078                         GeeLinkedListNode* _tmp12_;
1079                         GeeLinkedListNode* _tmp13_;
1080                         GeeLinkedListNode* _tmp14_;
1081                         GeeLinkedListNode* _tmp15_;
1082                         _tmp10_ = n;
1083                         _tmp11_ = self->priv->_head;
1084                         self->priv->_head = NULL;
1085                         _gee_linked_list_node_free0 (_tmp10_->next);
1086                         _tmp10_->next = _tmp11_;
1087                         _tmp12_ = n;
1088                         _tmp13_ = _tmp12_->next;
1089                         _tmp14_ = n;
1090                         _tmp13_->prev = _tmp14_;
1091                         _tmp15_ = n;
1092                         n = NULL;
1093                         _gee_linked_list_node_free0 (self->priv->_head);
1094                         self->priv->_head = _tmp15_;
1095                 } else {
1096                         GeeLinkedListNode* _tmp16_;
1097                         GeeLinkedListNode* prev;
1098                         GeeLinkedListNode* _tmp24_;
1099                         GeeLinkedListNode* _tmp25_;
1100                         GeeLinkedListNode* _tmp26_;
1101                         GeeLinkedListNode* _tmp27_;
1102                         GeeLinkedListNode* _tmp28_;
1103                         GeeLinkedListNode* _tmp29_;
1104                         GeeLinkedListNode* _tmp30_;
1105                         GeeLinkedListNode* _tmp31_;
1106                         GeeLinkedListNode* _tmp32_;
1107                         GeeLinkedListNode* _tmp33_;
1108                         _tmp16_ = self->priv->_head;
1109                         prev = _tmp16_;
1110                         {
1111                                 gint i;
1112                                 i = 0;
1113                                 {
1114                                         gboolean _tmp17_;
1115                                         _tmp17_ = TRUE;
1116                                         while (TRUE) {
1117                                                 gboolean _tmp18_;
1118                                                 gint _tmp20_;
1119                                                 gint _tmp21_;
1120                                                 GeeLinkedListNode* _tmp22_;
1121                                                 GeeLinkedListNode* _tmp23_;
1122                                                 _tmp18_ = _tmp17_;
1123                                                 if (!_tmp18_) {
1124                                                         gint _tmp19_;
1125                                                         _tmp19_ = i;
1126                                                         i = _tmp19_ + 1;
1127                                                 }
1128                                                 _tmp17_ = FALSE;
1129                                                 _tmp20_ = i;
1130                                                 _tmp21_ = index;
1131                                                 if (!(_tmp20_ < (_tmp21_ - 1))) {
1132                                                         break;
1133                                                 }
1134                                                 _tmp22_ = prev;
1135                                                 _tmp23_ = _tmp22_->next;
1136                                                 prev = _tmp23_;
1137                                         }
1138                                 }
1139                         }
1140                         _tmp24_ = n;
1141                         _tmp25_ = prev;
1142                         _tmp24_->prev = _tmp25_;
1143                         _tmp26_ = n;
1144                         _tmp27_ = prev;
1145                         _tmp28_ = _tmp27_->next;
1146                         _tmp27_->next = NULL;
1147                         _gee_linked_list_node_free0 (_tmp26_->next);
1148                         _tmp26_->next = _tmp28_;
1149                         _tmp29_ = n;
1150                         _tmp30_ = _tmp29_->next;
1151                         _tmp31_ = n;
1152                         _tmp30_->prev = _tmp31_;
1153                         _tmp32_ = prev;
1154                         _tmp33_ = n;
1155                         n = NULL;
1156                         _gee_linked_list_node_free0 (_tmp32_->next);
1157                         _tmp32_->next = _tmp33_;
1158                 }
1159                 _tmp34_ = self->priv->_size;
1160                 self->priv->_size = _tmp34_ + 1;
1161                 _gee_linked_list_node_free0 (n);
1162         }
1163 }
1164
1165
1166 /**
1167  * {@inheritDoc}
1168  */
1169 static gpointer gee_linked_list_real_remove_at (GeeAbstractList* base, gint index) {
1170         GeeLinkedList * self;
1171         gpointer result = NULL;
1172         gint _tmp0_;
1173         gint _tmp1_;
1174         gint _tmp2_;
1175         gint _tmp3_;
1176         GeeLinkedListNode* _tmp4_ = NULL;
1177         GeeLinkedListNode* n;
1178         gconstpointer _tmp5_;
1179         gpointer _tmp6_;
1180         gpointer element;
1181         self = (GeeLinkedList*) base;
1182         _tmp0_ = index;
1183         _vala_assert (_tmp0_ >= 0, "index >= 0");
1184         _tmp1_ = index;
1185         _tmp2_ = self->priv->_size;
1186         _vala_assert (_tmp1_ < _tmp2_, "index < this._size");
1187         _tmp3_ = index;
1188         _tmp4_ = _gee_linked_list_get_node_at (self, _tmp3_);
1189         n = _tmp4_;
1190         _vala_assert (n != NULL, "n != null");
1191         _tmp5_ = n->data;
1192         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
1193         element = _tmp6_;
1194         _gee_linked_list_remove_node (self, n);
1195         result = element;
1196         return result;
1197 }
1198
1199
1200 /**
1201  * {@inheritDoc}
1202  */
1203 static GeeList* gee_linked_list_real_slice (GeeAbstractList* base, gint start, gint stop) {
1204         GeeLinkedList * self;
1205         GeeList* result = NULL;
1206         gint _tmp0_;
1207         gint _tmp1_;
1208         gint _tmp2_;
1209         gint _tmp3_;
1210         gint _tmp4_;
1211         GeeEqualDataFunc _tmp5_;
1212         void* _tmp5__target;
1213         GeeEqualDataFunc _tmp6_;
1214         void* _tmp6__target;
1215         GeeLinkedList* _tmp7_;
1216         GeeList* slice;
1217         gint _tmp8_;
1218         GeeLinkedListNode* _tmp9_ = NULL;
1219         GeeLinkedListNode* n;
1220         self = (GeeLinkedList*) base;
1221         _tmp0_ = start;
1222         _tmp1_ = stop;
1223         g_return_val_if_fail (_tmp0_ <= _tmp1_, NULL);
1224         _tmp2_ = start;
1225         g_return_val_if_fail (_tmp2_ >= 0, NULL);
1226         _tmp3_ = stop;
1227         _tmp4_ = self->priv->_size;
1228         g_return_val_if_fail (_tmp3_ <= _tmp4_, NULL);
1229         _tmp5_ = gee_linked_list_get_equal_func (self, &_tmp5__target);
1230         _tmp6_ = _tmp5_;
1231         _tmp6__target = _tmp5__target;
1232         _tmp7_ = gee_linked_list_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp6_, _tmp6__target, NULL);
1233         slice = (GeeList*) _tmp7_;
1234         _tmp8_ = start;
1235         _tmp9_ = _gee_linked_list_get_node_at (self, _tmp8_);
1236         n = _tmp9_;
1237         {
1238                 gint _tmp10_;
1239                 gint i;
1240                 _tmp10_ = start;
1241                 i = _tmp10_;
1242                 {
1243                         gboolean _tmp11_;
1244                         _tmp11_ = TRUE;
1245                         while (TRUE) {
1246                                 gboolean _tmp12_;
1247                                 gint _tmp14_;
1248                                 gint _tmp15_;
1249                                 GeeList* _tmp16_;
1250                                 GeeLinkedListNode* _tmp17_;
1251                                 gconstpointer _tmp18_;
1252                                 GeeLinkedListNode* _tmp19_;
1253                                 GeeLinkedListNode* _tmp20_;
1254                                 _tmp12_ = _tmp11_;
1255                                 if (!_tmp12_) {
1256                                         gint _tmp13_;
1257                                         _tmp13_ = i;
1258                                         i = _tmp13_ + 1;
1259                                 }
1260                                 _tmp11_ = FALSE;
1261                                 _tmp14_ = i;
1262                                 _tmp15_ = stop;
1263                                 if (!(_tmp14_ < _tmp15_)) {
1264                                         break;
1265                                 }
1266                                 _tmp16_ = slice;
1267                                 _tmp17_ = n;
1268                                 _tmp18_ = _tmp17_->data;
1269                                 gee_collection_add ((GeeCollection*) _tmp16_, _tmp18_);
1270                                 _tmp19_ = n;
1271                                 _tmp20_ = _tmp19_->next;
1272                                 n = _tmp20_;
1273                         }
1274                 }
1275         }
1276         result = slice;
1277         return result;
1278 }
1279
1280
1281 /**
1282  * {@inheritDoc}
1283  */
1284 gpointer gee_linked_list_first (GeeLinkedList* self) {
1285         gpointer result = NULL;
1286         gint _tmp0_;
1287         GeeLinkedListNode* _tmp1_;
1288         gconstpointer _tmp2_;
1289         gpointer _tmp3_;
1290         g_return_val_if_fail (self != NULL, NULL);
1291         _tmp0_ = self->priv->_size;
1292         _vala_assert (_tmp0_ > 0, "_size > 0");
1293         _tmp1_ = self->priv->_head;
1294         _tmp2_ = _tmp1_->data;
1295         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
1296         result = _tmp3_;
1297         return result;
1298 }
1299
1300
1301 /**
1302  * {@inheritDoc}
1303  */
1304 gpointer gee_linked_list_last (GeeLinkedList* self) {
1305         gpointer result = NULL;
1306         gint _tmp0_;
1307         GeeLinkedListNode* _tmp1_;
1308         gconstpointer _tmp2_;
1309         gpointer _tmp3_;
1310         g_return_val_if_fail (self != NULL, NULL);
1311         _tmp0_ = self->priv->_size;
1312         _vala_assert (_tmp0_ > 0, "_size > 0");
1313         _tmp1_ = self->priv->_tail;
1314         _tmp2_ = _tmp1_->data;
1315         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
1316         result = _tmp3_;
1317         return result;
1318 }
1319
1320
1321 /**
1322  * {@inheritDoc}
1323  */
1324 static gboolean gee_linked_list_real_offer (GeeQueue* base, gconstpointer element) {
1325         GeeLinkedList * self;
1326         gboolean result = FALSE;
1327         gconstpointer _tmp0_;
1328         gboolean _tmp1_ = FALSE;
1329         self = (GeeLinkedList*) base;
1330         _tmp0_ = element;
1331         _tmp1_ = gee_deque_offer_tail ((GeeDeque*) self, _tmp0_);
1332         result = _tmp1_;
1333         return result;
1334 }
1335
1336
1337 /**
1338  * {@inheritDoc}
1339  */
1340 static gpointer gee_linked_list_real_peek (GeeQueue* base) {
1341         GeeLinkedList * self;
1342         gpointer result = NULL;
1343         gpointer _tmp0_ = NULL;
1344         self = (GeeLinkedList*) base;
1345         _tmp0_ = gee_deque_peek_head ((GeeDeque*) self);
1346         result = _tmp0_;
1347         return result;
1348 }
1349
1350
1351 /**
1352  * {@inheritDoc}
1353  */
1354 static gpointer gee_linked_list_real_poll (GeeQueue* base) {
1355         GeeLinkedList * self;
1356         gpointer result = NULL;
1357         gpointer _tmp0_ = NULL;
1358         self = (GeeLinkedList*) base;
1359         _tmp0_ = gee_deque_poll_head ((GeeDeque*) self);
1360         result = _tmp0_;
1361         return result;
1362 }
1363
1364
1365 /**
1366  * {@inheritDoc}
1367  */
1368 static gint gee_linked_list_real_drain (GeeQueue* base, GeeCollection* recipient, gint amount) {
1369         GeeLinkedList * self;
1370         gint result = 0;
1371         GeeCollection* _tmp0_;
1372         gint _tmp1_;
1373         gint _tmp2_ = 0;
1374         self = (GeeLinkedList*) base;
1375         g_return_val_if_fail (recipient != NULL, 0);
1376         _tmp0_ = recipient;
1377         _tmp1_ = amount;
1378         _tmp2_ = gee_deque_drain_head ((GeeDeque*) self, _tmp0_, _tmp1_);
1379         result = _tmp2_;
1380         return result;
1381 }
1382
1383
1384 /**
1385  * {@inheritDoc}
1386  */
1387 static gboolean gee_linked_list_real_offer_head (GeeDeque* base, gconstpointer element) {
1388         GeeLinkedList * self;
1389         gboolean result = FALSE;
1390         gconstpointer _tmp0_;
1391         self = (GeeLinkedList*) base;
1392         _tmp0_ = element;
1393         gee_abstract_list_insert ((GeeAbstractList*) self, 0, _tmp0_);
1394         result = TRUE;
1395         return result;
1396 }
1397
1398
1399 /**
1400  * {@inheritDoc}
1401  */
1402 static gpointer gee_linked_list_real_peek_head (GeeDeque* base) {
1403         GeeLinkedList * self;
1404         gpointer result = NULL;
1405         gint _tmp0_;
1406         gpointer _tmp1_ = NULL;
1407         self = (GeeLinkedList*) base;
1408         _tmp0_ = self->priv->_size;
1409         if (_tmp0_ == 0) {
1410                 result = NULL;
1411                 return result;
1412         }
1413         _tmp1_ = gee_abstract_list_get ((GeeAbstractList*) self, 0);
1414         result = _tmp1_;
1415         return result;
1416 }
1417
1418
1419 /**
1420  * {@inheritDoc}
1421  */
1422 static gpointer gee_linked_list_real_poll_head (GeeDeque* base) {
1423         GeeLinkedList * self;
1424         gpointer result = NULL;
1425         gint _tmp0_;
1426         gpointer _tmp1_ = NULL;
1427         self = (GeeLinkedList*) base;
1428         _tmp0_ = self->priv->_size;
1429         if (_tmp0_ == 0) {
1430                 result = NULL;
1431                 return result;
1432         }
1433         _tmp1_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, 0);
1434         result = _tmp1_;
1435         return result;
1436 }
1437
1438
1439 /**
1440  * {@inheritDoc}
1441  */
1442 static gint gee_linked_list_real_drain_head (GeeDeque* base, GeeCollection* recipient, gint amount) {
1443         GeeLinkedList * self;
1444         gint result = 0;
1445         gint _tmp0_;
1446         gint _tmp11_;
1447         self = (GeeLinkedList*) base;
1448         g_return_val_if_fail (recipient != NULL, 0);
1449         _tmp0_ = amount;
1450         if (_tmp0_ == (-1)) {
1451                 gint _tmp1_;
1452                 _tmp1_ = self->priv->_size;
1453                 amount = _tmp1_;
1454         }
1455         {
1456                 gint i;
1457                 i = 0;
1458                 {
1459                         gboolean _tmp2_;
1460                         _tmp2_ = TRUE;
1461                         while (TRUE) {
1462                                 gboolean _tmp3_;
1463                                 gint _tmp5_;
1464                                 gint _tmp6_;
1465                                 gint _tmp7_;
1466                                 GeeCollection* _tmp8_;
1467                                 gpointer _tmp9_ = NULL;
1468                                 gpointer _tmp10_;
1469                                 _tmp3_ = _tmp2_;
1470                                 if (!_tmp3_) {
1471                                         gint _tmp4_;
1472                                         _tmp4_ = i;
1473                                         i = _tmp4_ + 1;
1474                                 }
1475                                 _tmp2_ = FALSE;
1476                                 _tmp5_ = i;
1477                                 _tmp6_ = amount;
1478                                 if (!(_tmp5_ < _tmp6_)) {
1479                                         break;
1480                                 }
1481                                 _tmp7_ = self->priv->_size;
1482                                 if (_tmp7_ == 0) {
1483                                         result = i;
1484                                         return result;
1485                                 }
1486                                 _tmp8_ = recipient;
1487                                 _tmp9_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, 0);
1488                                 _tmp10_ = _tmp9_;
1489                                 gee_collection_add (_tmp8_, _tmp10_);
1490                                 ((_tmp10_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp10_ = (self->priv->g_destroy_func (_tmp10_), NULL));
1491                         }
1492                 }
1493         }
1494         _tmp11_ = amount;
1495         result = _tmp11_;
1496         return result;
1497 }
1498
1499
1500 /**
1501  * {@inheritDoc}
1502  */
1503 static gboolean gee_linked_list_real_offer_tail (GeeDeque* base, gconstpointer element) {
1504         GeeLinkedList * self;
1505         gboolean result = FALSE;
1506         gconstpointer _tmp0_;
1507         gboolean _tmp1_ = FALSE;
1508         self = (GeeLinkedList*) base;
1509         _tmp0_ = element;
1510         _tmp1_ = gee_abstract_collection_add ((GeeAbstractCollection*) self, _tmp0_);
1511         result = _tmp1_;
1512         return result;
1513 }
1514
1515
1516 /**
1517  * {@inheritDoc}
1518  */
1519 static gpointer gee_linked_list_real_peek_tail (GeeDeque* base) {
1520         GeeLinkedList * self;
1521         gpointer result = NULL;
1522         gint _tmp0_;
1523         gint _tmp1_;
1524         gpointer _tmp2_ = NULL;
1525         self = (GeeLinkedList*) base;
1526         _tmp0_ = self->priv->_size;
1527         if (_tmp0_ == 0) {
1528                 result = NULL;
1529                 return result;
1530         }
1531         _tmp1_ = self->priv->_size;
1532         _tmp2_ = gee_abstract_list_get ((GeeAbstractList*) self, _tmp1_ - 1);
1533         result = _tmp2_;
1534         return result;
1535 }
1536
1537
1538 /**
1539  * {@inheritDoc}
1540  */
1541 static gpointer gee_linked_list_real_poll_tail (GeeDeque* base) {
1542         GeeLinkedList * self;
1543         gpointer result = NULL;
1544         gint _tmp0_;
1545         gint _tmp1_;
1546         gpointer _tmp2_ = NULL;
1547         self = (GeeLinkedList*) base;
1548         _tmp0_ = self->priv->_size;
1549         if (_tmp0_ == 0) {
1550                 result = NULL;
1551                 return result;
1552         }
1553         _tmp1_ = self->priv->_size;
1554         _tmp2_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, _tmp1_ - 1);
1555         result = _tmp2_;
1556         return result;
1557 }
1558
1559
1560 /**
1561  * {@inheritDoc}
1562  */
1563 static gint gee_linked_list_real_drain_tail (GeeDeque* base, GeeCollection* recipient, gint amount) {
1564         GeeLinkedList * self;
1565         gint result = 0;
1566         gint _tmp0_;
1567         gint _tmp12_;
1568         self = (GeeLinkedList*) base;
1569         g_return_val_if_fail (recipient != NULL, 0);
1570         _tmp0_ = amount;
1571         if (_tmp0_ == (-1)) {
1572                 gint _tmp1_;
1573                 _tmp1_ = self->priv->_size;
1574                 amount = _tmp1_;
1575         }
1576         {
1577                 gint i;
1578                 i = 0;
1579                 {
1580                         gboolean _tmp2_;
1581                         _tmp2_ = TRUE;
1582                         while (TRUE) {
1583                                 gboolean _tmp3_;
1584                                 gint _tmp5_;
1585                                 gint _tmp6_;
1586                                 gint _tmp7_;
1587                                 GeeCollection* _tmp8_;
1588                                 gint _tmp9_;
1589                                 gpointer _tmp10_ = NULL;
1590                                 gpointer _tmp11_;
1591                                 _tmp3_ = _tmp2_;
1592                                 if (!_tmp3_) {
1593                                         gint _tmp4_;
1594                                         _tmp4_ = i;
1595                                         i = _tmp4_ + 1;
1596                                 }
1597                                 _tmp2_ = FALSE;
1598                                 _tmp5_ = i;
1599                                 _tmp6_ = amount;
1600                                 if (!(_tmp5_ < _tmp6_)) {
1601                                         break;
1602                                 }
1603                                 _tmp7_ = self->priv->_size;
1604                                 if (_tmp7_ == 0) {
1605                                         result = i;
1606                                         return result;
1607                                 }
1608                                 _tmp8_ = recipient;
1609                                 _tmp9_ = self->priv->_size;
1610                                 _tmp10_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, _tmp9_ - 1);
1611                                 _tmp11_ = _tmp10_;
1612                                 gee_collection_add (_tmp8_, _tmp11_);
1613                                 ((_tmp11_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp11_ = (self->priv->g_destroy_func (_tmp11_), NULL));
1614                         }
1615                 }
1616         }
1617         _tmp12_ = amount;
1618         result = _tmp12_;
1619         return result;
1620 }
1621
1622
1623 static GeeLinkedListNode* _gee_linked_list_get_node_at (GeeLinkedList* self, gint index) {
1624         GeeLinkedListNode* result = NULL;
1625         GeeLinkedListNode* n;
1626         gint _tmp0_;
1627         GeeLinkedListNode* _tmp24_;
1628         g_return_val_if_fail (self != NULL, NULL);
1629         n = NULL;
1630         _tmp0_ = index;
1631         if (_tmp0_ == 0) {
1632                 GeeLinkedListNode* _tmp1_;
1633                 _tmp1_ = self->priv->_head;
1634                 n = _tmp1_;
1635         } else {
1636                 gint _tmp2_;
1637                 gint _tmp3_;
1638                 _tmp2_ = index;
1639                 _tmp3_ = self->priv->_size;
1640                 if (_tmp2_ == (_tmp3_ - 1)) {
1641                         GeeLinkedListNode* _tmp4_;
1642                         _tmp4_ = self->priv->_tail;
1643                         n = _tmp4_;
1644                 } else {
1645                         gint _tmp5_;
1646                         gint _tmp6_;
1647                         _tmp5_ = index;
1648                         _tmp6_ = self->priv->_size;
1649                         if (_tmp5_ <= (_tmp6_ / 2)) {
1650                                 GeeLinkedListNode* _tmp7_;
1651                                 _tmp7_ = self->priv->_head;
1652                                 n = _tmp7_;
1653                                 {
1654                                         gint i;
1655                                         i = 0;
1656                                         {
1657                                                 gboolean _tmp8_;
1658                                                 _tmp8_ = TRUE;
1659                                                 while (TRUE) {
1660                                                         gboolean _tmp9_;
1661                                                         gint _tmp11_;
1662                                                         gint _tmp12_;
1663                                                         GeeLinkedListNode* _tmp13_;
1664                                                         GeeLinkedListNode* _tmp14_;
1665                                                         _tmp9_ = _tmp8_;
1666                                                         if (!_tmp9_) {
1667                                                                 gint _tmp10_;
1668                                                                 _tmp10_ = i;
1669                                                                 i = _tmp10_ + 1;
1670                                                         }
1671                                                         _tmp8_ = FALSE;
1672                                                         _tmp11_ = index;
1673                                                         _tmp12_ = i;
1674                                                         if (!(_tmp11_ != _tmp12_)) {
1675                                                                 break;
1676                                                         }
1677                                                         _tmp13_ = n;
1678                                                         _tmp14_ = _tmp13_->next;
1679                                                         n = _tmp14_;
1680                                                 }
1681                                         }
1682                                 }
1683                         } else {
1684                                 GeeLinkedListNode* _tmp15_;
1685                                 _tmp15_ = self->priv->_tail;
1686                                 n = _tmp15_;
1687                                 {
1688                                         gint _tmp16_;
1689                                         gint i;
1690                                         _tmp16_ = self->priv->_size;
1691                                         i = _tmp16_ - 1;
1692                                         {
1693                                                 gboolean _tmp17_;
1694                                                 _tmp17_ = TRUE;
1695                                                 while (TRUE) {
1696                                                         gboolean _tmp18_;
1697                                                         gint _tmp20_;
1698                                                         gint _tmp21_;
1699                                                         GeeLinkedListNode* _tmp22_;
1700                                                         GeeLinkedListNode* _tmp23_;
1701                                                         _tmp18_ = _tmp17_;
1702                                                         if (!_tmp18_) {
1703                                                                 gint _tmp19_;
1704                                                                 _tmp19_ = i;
1705                                                                 i = _tmp19_ - 1;
1706                                                         }
1707                                                         _tmp17_ = FALSE;
1708                                                         _tmp20_ = index;
1709                                                         _tmp21_ = i;
1710                                                         if (!(_tmp20_ != _tmp21_)) {
1711                                                                 break;
1712                                                         }
1713                                                         _tmp22_ = n;
1714                                                         _tmp23_ = _tmp22_->prev;
1715                                                         n = _tmp23_;
1716                                                 }
1717                                         }
1718                                 }
1719                         }
1720                 }
1721         }
1722         _tmp24_ = n;
1723         result = _tmp24_;
1724         return result;
1725 }
1726
1727
1728 static void _gee_linked_list_remove_node (GeeLinkedList* self, GeeLinkedListNode* _n) {
1729         GeeLinkedListNode* n = NULL;
1730         GeeLinkedListNode* next = NULL;
1731         GeeLinkedListNode* _tmp0_;
1732         GeeLinkedListNode* _tmp1_;
1733         GeeLinkedListNode* _tmp14_;
1734         GeeLinkedListNode* _tmp15_;
1735         GeeLinkedListNode* _tmp21_;
1736         GeeLinkedListNode* _tmp22_;
1737         GeeLinkedListNode* _tmp23_;
1738         gint _tmp24_;
1739         gint _tmp25_;
1740         g_return_if_fail (self != NULL);
1741         g_return_if_fail (_n != NULL);
1742         _tmp0_ = _n;
1743         _tmp1_ = self->priv->_head;
1744         if (_tmp0_ == _tmp1_) {
1745                 GeeLinkedListNode* _tmp2_;
1746                 GeeLinkedListNode* _tmp3_;
1747                 GeeLinkedListNode* _tmp4_;
1748                 GeeLinkedListNode* _tmp5_;
1749                 _tmp2_ = self->priv->_head;
1750                 self->priv->_head = NULL;
1751                 _gee_linked_list_node_free0 (n);
1752                 n = _tmp2_;
1753                 _tmp3_ = n;
1754                 _tmp4_ = _tmp3_->next;
1755                 _tmp3_->next = NULL;
1756                 _gee_linked_list_node_free0 (self->priv->_head);
1757                 self->priv->_head = _tmp4_;
1758                 _tmp5_ = self->priv->_head;
1759                 next = _tmp5_;
1760         } else {
1761                 GeeLinkedListNode* _tmp6_;
1762                 GeeLinkedListNode* _tmp7_;
1763                 GeeLinkedListNode* _tmp8_;
1764                 GeeLinkedListNode* _tmp9_;
1765                 GeeLinkedListNode* _tmp10_;
1766                 GeeLinkedListNode* _tmp11_;
1767                 GeeLinkedListNode* _tmp12_;
1768                 GeeLinkedListNode* _tmp13_;
1769                 _tmp6_ = _n;
1770                 _tmp7_ = _tmp6_->prev;
1771                 _tmp8_ = _tmp7_->next;
1772                 _tmp7_->next = NULL;
1773                 _gee_linked_list_node_free0 (n);
1774                 n = _tmp8_;
1775                 _tmp9_ = n;
1776                 _tmp10_ = _tmp9_->prev;
1777                 _tmp11_ = n;
1778                 _tmp12_ = _tmp11_->next;
1779                 _tmp11_->next = NULL;
1780                 _gee_linked_list_node_free0 (_tmp10_->next);
1781                 _tmp10_->next = _tmp12_;
1782                 _tmp13_ = _tmp10_->next;
1783                 next = _tmp13_;
1784         }
1785         _tmp14_ = n;
1786         _tmp15_ = self->priv->_tail;
1787         if (_tmp14_ == _tmp15_) {
1788                 GeeLinkedListNode* _tmp16_;
1789                 GeeLinkedListNode* _tmp17_;
1790                 _tmp16_ = n;
1791                 _tmp17_ = _tmp16_->prev;
1792                 self->priv->_tail = _tmp17_;
1793         } else {
1794                 GeeLinkedListNode* _tmp18_;
1795                 GeeLinkedListNode* _tmp19_;
1796                 GeeLinkedListNode* _tmp20_;
1797                 _tmp18_ = next;
1798                 _tmp19_ = n;
1799                 _tmp20_ = _tmp19_->prev;
1800                 _tmp18_->prev = _tmp20_;
1801         }
1802         _tmp21_ = n;
1803         _tmp21_->prev = NULL;
1804         _tmp22_ = n;
1805         _gee_linked_list_node_free0 (_tmp22_->next);
1806         _tmp22_->next = NULL;
1807         _tmp23_ = n;
1808         ((_tmp23_->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp23_->data = (self->priv->g_destroy_func (_tmp23_->data), NULL));
1809         _tmp23_->data = NULL;
1810         _tmp24_ = self->priv->_stamp;
1811         self->priv->_stamp = _tmp24_ + 1;
1812         _tmp25_ = self->priv->_size;
1813         self->priv->_size = _tmp25_ - 1;
1814         _gee_linked_list_node_free0 (n);
1815 }
1816
1817
1818 GeeEqualDataFunc gee_linked_list_get_equal_func (GeeLinkedList* self, gpointer* result_target) {
1819         GeeEqualDataFunc result;
1820         GeeEqualDataFunc _tmp0_;
1821         void* _tmp0__target;
1822         GeeEqualDataFunc _tmp1_;
1823         void* _tmp1__target;
1824         g_return_val_if_fail (self != NULL, NULL);
1825         _tmp0_ = self->priv->_equal_func;
1826         _tmp0__target = self->priv->_equal_func_target;
1827         _tmp1_ = _tmp0_;
1828         _tmp1__target = _tmp0__target;
1829         *result_target = _tmp1__target;
1830         result = _tmp1_;
1831         return result;
1832 }
1833
1834
1835 static void gee_linked_list_set_equal_func (GeeLinkedList* self, GeeEqualDataFunc value, gpointer value_target) {
1836         GeeEqualDataFunc _tmp0_;
1837         void* _tmp0__target;
1838         g_return_if_fail (self != NULL);
1839         _tmp0_ = value;
1840         _tmp0__target = value_target;
1841         (self->priv->_equal_func_target_destroy_notify == NULL) ? NULL : (self->priv->_equal_func_target_destroy_notify (self->priv->_equal_func_target), NULL);
1842         self->priv->_equal_func = NULL;
1843         self->priv->_equal_func_target = NULL;
1844         self->priv->_equal_func_target_destroy_notify = NULL;
1845         self->priv->_equal_func = _tmp0_;
1846         self->priv->_equal_func_target = _tmp0__target;
1847         self->priv->_equal_func_target_destroy_notify = NULL;
1848 }
1849
1850
1851 static gint gee_linked_list_real_get_size (GeeAbstractCollection* base) {
1852         gint result;
1853         GeeLinkedList* self;
1854         gint _tmp0_;
1855         self = (GeeLinkedList*) base;
1856         _tmp0_ = self->priv->_size;
1857         result = _tmp0_;
1858         return result;
1859 }
1860
1861
1862 static gboolean gee_linked_list_real_get_read_only (GeeAbstractCollection* base) {
1863         gboolean result;
1864         GeeLinkedList* self;
1865         self = (GeeLinkedList*) base;
1866         result = FALSE;
1867         return result;
1868 }
1869
1870
1871 static gint gee_linked_list_real_get_capacity (GeeQueue* base) {
1872         gint result;
1873         GeeLinkedList* self;
1874         self = (GeeLinkedList*) base;
1875         result = GEE_QUEUE_UNBOUNDED_CAPACITY;
1876         return result;
1877 }
1878
1879
1880 static gint gee_linked_list_real_get_remaining_capacity (GeeQueue* base) {
1881         gint result;
1882         GeeLinkedList* self;
1883         self = (GeeLinkedList*) base;
1884         result = GEE_QUEUE_UNBOUNDED_CAPACITY;
1885         return result;
1886 }
1887
1888
1889 static gboolean gee_linked_list_real_get_is_full (GeeQueue* base) {
1890         gboolean result;
1891         GeeLinkedList* self;
1892         self = (GeeLinkedList*) base;
1893         result = FALSE;
1894         return result;
1895 }
1896
1897
1898 static GeeLinkedListNode* gee_linked_list_node_new (gpointer data) {
1899         GeeLinkedListNode* self;
1900         gconstpointer _tmp0_;
1901         self = g_slice_new0 (GeeLinkedListNode);
1902         gee_linked_list_node_instance_init (self);
1903         _tmp0_ = data;
1904         self->data = _tmp0_;
1905         return self;
1906 }
1907
1908
1909 static void gee_linked_list_node_instance_init (GeeLinkedListNode * self) {
1910         self->prev = NULL;
1911         self->next = NULL;
1912 }
1913
1914
1915 static void gee_linked_list_node_free (GeeLinkedListNode* self) {
1916         _gee_linked_list_node_free0 (self->next);
1917         g_slice_free (GeeLinkedListNode, self);
1918 }
1919
1920
1921 static gpointer _g_object_ref0 (gpointer self) {
1922         return self ? g_object_ref (self) : NULL;
1923 }
1924
1925
1926 static GeeLinkedListIterator* gee_linked_list_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list) {
1927         GeeLinkedListIterator * self = NULL;
1928         GeeLinkedList* _tmp0_;
1929         GeeLinkedList* _tmp1_;
1930         GeeLinkedList* _tmp2_;
1931         gint _tmp3_;
1932         g_return_val_if_fail (list != NULL, NULL);
1933         self = (GeeLinkedListIterator*) g_object_new (object_type, NULL);
1934         self->priv->g_type = g_type;
1935         self->priv->g_dup_func = g_dup_func;
1936         self->priv->g_destroy_func = g_destroy_func;
1937         _tmp0_ = list;
1938         _tmp1_ = _g_object_ref0 (_tmp0_);
1939         _g_object_unref0 (self->priv->_list);
1940         self->priv->_list = _tmp1_;
1941         self->priv->position = NULL;
1942         self->priv->_index = -1;
1943         _tmp2_ = list;
1944         _tmp3_ = _tmp2_->priv->_stamp;
1945         self->priv->_stamp = _tmp3_;
1946         return self;
1947 }
1948
1949
1950 static GeeLinkedListIterator* gee_linked_list_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list) {
1951         return gee_linked_list_iterator_construct (GEE_LINKED_LIST_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, list);
1952 }
1953
1954
1955 static gboolean gee_linked_list_iterator_real_next (GeeIterator* base) {
1956         GeeLinkedListIterator * self;
1957         gboolean result = FALSE;
1958         gint _tmp0_;
1959         GeeLinkedList* _tmp1_;
1960         gint _tmp2_;
1961         gboolean _tmp3_;
1962         self = (GeeLinkedListIterator*) base;
1963         _tmp0_ = self->priv->_stamp;
1964         _tmp1_ = self->priv->_list;
1965         _tmp2_ = _tmp1_->priv->_stamp;
1966         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1967         _tmp3_ = self->priv->removed;
1968         if (_tmp3_) {
1969                 GeeLinkedListNode* _tmp4_;
1970                 _tmp4_ = self->priv->position;
1971                 if (_tmp4_ != NULL) {
1972                         self->priv->removed = FALSE;
1973                         result = TRUE;
1974                         return result;
1975                 } else {
1976                         result = FALSE;
1977                         return result;
1978                 }
1979         } else {
1980                 gboolean _tmp5_;
1981                 _tmp5_ = self->priv->started;
1982                 if (!_tmp5_) {
1983                         GeeLinkedList* _tmp6_;
1984                         GeeLinkedListNode* _tmp7_;
1985                         _tmp6_ = self->priv->_list;
1986                         _tmp7_ = _tmp6_->priv->_head;
1987                         if (_tmp7_ != NULL) {
1988                                 GeeLinkedList* _tmp8_;
1989                                 GeeLinkedListNode* _tmp9_;
1990                                 gint _tmp10_;
1991                                 self->priv->started = TRUE;
1992                                 _tmp8_ = self->priv->_list;
1993                                 _tmp9_ = _tmp8_->priv->_head;
1994                                 self->priv->position = _tmp9_;
1995                                 _tmp10_ = self->priv->_index;
1996                                 self->priv->_index = _tmp10_ + 1;
1997                                 result = TRUE;
1998                                 return result;
1999                         } else {
2000                                 result = FALSE;
2001                                 return result;
2002                         }
2003                 } else {
2004                         GeeLinkedListNode* _tmp11_;
2005                         _tmp11_ = self->priv->position;
2006                         if (_tmp11_ != NULL) {
2007                                 GeeLinkedListNode* _tmp12_;
2008                                 GeeLinkedListNode* _tmp13_;
2009                                 _tmp12_ = self->priv->position;
2010                                 _tmp13_ = _tmp12_->next;
2011                                 if (_tmp13_ != NULL) {
2012                                         GeeLinkedListNode* _tmp14_;
2013                                         GeeLinkedListNode* _tmp15_;
2014                                         gint _tmp16_;
2015                                         _tmp14_ = self->priv->position;
2016                                         _tmp15_ = _tmp14_->next;
2017                                         self->priv->position = _tmp15_;
2018                                         _tmp16_ = self->priv->_index;
2019                                         self->priv->_index = _tmp16_ + 1;
2020                                         result = TRUE;
2021                                         return result;
2022                                 } else {
2023                                         result = FALSE;
2024                                         return result;
2025                                 }
2026                         }
2027                 }
2028         }
2029         result = FALSE;
2030         return result;
2031 }
2032
2033
2034 static gboolean gee_linked_list_iterator_real_has_next (GeeIterator* base) {
2035         GeeLinkedListIterator * self;
2036         gboolean result = FALSE;
2037         gint _tmp0_;
2038         GeeLinkedList* _tmp1_;
2039         gint _tmp2_;
2040         gboolean _tmp3_;
2041         self = (GeeLinkedListIterator*) base;
2042         _tmp0_ = self->priv->_stamp;
2043         _tmp1_ = self->priv->_list;
2044         _tmp2_ = _tmp1_->priv->_stamp;
2045         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2046         _tmp3_ = self->priv->removed;
2047         if (_tmp3_) {
2048                 GeeLinkedListNode* _tmp4_;
2049                 _tmp4_ = self->priv->position;
2050                 result = _tmp4_ != NULL;
2051                 return result;
2052         } else {
2053                 gboolean _tmp5_;
2054                 _tmp5_ = self->priv->started;
2055                 if (!_tmp5_) {
2056                         GeeLinkedList* _tmp6_;
2057                         GeeLinkedListNode* _tmp7_;
2058                         _tmp6_ = self->priv->_list;
2059                         _tmp7_ = _tmp6_->priv->_head;
2060                         result = _tmp7_ != NULL;
2061                         return result;
2062                 } else {
2063                         GeeLinkedListNode* _tmp8_;
2064                         _tmp8_ = self->priv->position;
2065                         if (_tmp8_ != NULL) {
2066                                 GeeLinkedListNode* _tmp9_;
2067                                 GeeLinkedListNode* _tmp10_;
2068                                 _tmp9_ = self->priv->position;
2069                                 _tmp10_ = _tmp9_->next;
2070                                 result = _tmp10_ != NULL;
2071                                 return result;
2072                         }
2073                 }
2074         }
2075         result = FALSE;
2076         return result;
2077 }
2078
2079
2080 static gboolean gee_linked_list_iterator_real_first (GeeBidirIterator* base) {
2081         GeeLinkedListIterator * self;
2082         gboolean result = FALSE;
2083         gint _tmp0_;
2084         GeeLinkedList* _tmp1_;
2085         gint _tmp2_;
2086         GeeLinkedList* _tmp3_;
2087         gint _tmp4_;
2088         gint _tmp5_;
2089         GeeLinkedList* _tmp6_;
2090         GeeLinkedListNode* _tmp7_;
2091         GeeLinkedListNode* _tmp8_;
2092         self = (GeeLinkedListIterator*) base;
2093         _tmp0_ = self->priv->_stamp;
2094         _tmp1_ = self->priv->_list;
2095         _tmp2_ = _tmp1_->priv->_stamp;
2096         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2097         _tmp3_ = self->priv->_list;
2098         _tmp4_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp3_);
2099         _tmp5_ = _tmp4_;
2100         if (_tmp5_ == 0) {
2101                 result = FALSE;
2102                 return result;
2103         }
2104         _tmp6_ = self->priv->_list;
2105         _tmp7_ = _tmp6_->priv->_head;
2106         self->priv->position = _tmp7_;
2107         self->priv->started = TRUE;
2108         self->priv->_index = 0;
2109         self->priv->removed = FALSE;
2110         _tmp8_ = self->priv->position;
2111         result = _tmp8_ != NULL;
2112         return result;
2113 }
2114
2115
2116 static gpointer gee_linked_list_iterator_real_get (GeeIterator* base) {
2117         GeeLinkedListIterator * self;
2118         gpointer result = NULL;
2119         gint _tmp0_;
2120         GeeLinkedList* _tmp1_;
2121         gint _tmp2_;
2122         GeeLinkedListNode* _tmp3_;
2123         GeeLinkedListNode* _tmp4_;
2124         gconstpointer _tmp5_;
2125         gpointer _tmp6_;
2126         self = (GeeLinkedListIterator*) base;
2127         _tmp0_ = self->priv->_stamp;
2128         _tmp1_ = self->priv->_list;
2129         _tmp2_ = _tmp1_->priv->_stamp;
2130         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2131         _tmp3_ = self->priv->position;
2132         _vala_assert (_tmp3_ != NULL, "this.position != null");
2133         _tmp4_ = self->priv->position;
2134         _tmp5_ = _tmp4_->data;
2135         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
2136         result = _tmp6_;
2137         return result;
2138 }
2139
2140
2141 static void gee_linked_list_iterator_real_remove (GeeIterator* base) {
2142         GeeLinkedListIterator * self;
2143         gint _tmp0_;
2144         GeeLinkedList* _tmp1_;
2145         gint _tmp2_;
2146         GeeLinkedListNode* _tmp3_;
2147         GeeLinkedListNode* _tmp4_;
2148         GeeLinkedListNode* _tmp5_;
2149         GeeLinkedListNode* new_position;
2150         GeeLinkedListNode* _tmp6_;
2151         GeeLinkedList* _tmp7_;
2152         GeeLinkedListNode* _tmp8_;
2153         GeeLinkedListNode* _tmp9_;
2154         GeeLinkedList* _tmp10_;
2155         gint _tmp11_;
2156         self = (GeeLinkedListIterator*) base;
2157         _tmp0_ = self->priv->_stamp;
2158         _tmp1_ = self->priv->_list;
2159         _tmp2_ = _tmp1_->priv->_stamp;
2160         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2161         _tmp3_ = self->priv->position;
2162         _vala_assert (_tmp3_ != NULL, "this.position != null");
2163         _tmp4_ = self->priv->position;
2164         _tmp5_ = _tmp4_->next;
2165         new_position = _tmp5_;
2166         _tmp6_ = new_position;
2167         if (_tmp6_ == NULL) {
2168                 self->priv->started = FALSE;
2169         }
2170         _tmp7_ = self->priv->_list;
2171         _tmp8_ = self->priv->position;
2172         _gee_linked_list_remove_node (_tmp7_, _tmp8_);
2173         _tmp9_ = new_position;
2174         self->priv->position = _tmp9_;
2175         self->priv->removed = TRUE;
2176         _tmp10_ = self->priv->_list;
2177         _tmp11_ = _tmp10_->priv->_stamp;
2178         self->priv->_stamp = _tmp11_;
2179 }
2180
2181
2182 static gboolean gee_linked_list_iterator_real_previous (GeeBidirIterator* base) {
2183         GeeLinkedListIterator * self;
2184         gboolean result = FALSE;
2185         gint _tmp0_;
2186         GeeLinkedList* _tmp1_;
2187         gint _tmp2_;
2188         gboolean _tmp3_;
2189         self = (GeeLinkedListIterator*) base;
2190         _tmp0_ = self->priv->_stamp;
2191         _tmp1_ = self->priv->_list;
2192         _tmp2_ = _tmp1_->priv->_stamp;
2193         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2194         _tmp3_ = self->priv->started;
2195         if (!_tmp3_) {
2196                 self->priv->position = NULL;
2197                 result = FALSE;
2198                 return result;
2199         } else {
2200                 gboolean _tmp4_ = FALSE;
2201                 GeeLinkedListNode* _tmp5_;
2202                 gboolean _tmp8_;
2203                 _tmp5_ = self->priv->position;
2204                 if (_tmp5_ != NULL) {
2205                         GeeLinkedListNode* _tmp6_;
2206                         GeeLinkedListNode* _tmp7_;
2207                         _tmp6_ = self->priv->position;
2208                         _tmp7_ = _tmp6_->prev;
2209                         _tmp4_ = _tmp7_ != NULL;
2210                 } else {
2211                         _tmp4_ = FALSE;
2212                 }
2213                 _tmp8_ = _tmp4_;
2214                 if (_tmp8_) {
2215                         GeeLinkedListNode* _tmp9_;
2216                         GeeLinkedListNode* _tmp10_;
2217                         gint _tmp11_;
2218                         _tmp9_ = self->priv->position;
2219                         _tmp10_ = _tmp9_->prev;
2220                         self->priv->position = _tmp10_;
2221                         _tmp11_ = self->priv->_index;
2222                         self->priv->_index = _tmp11_ - 1;
2223                         result = TRUE;
2224                         return result;
2225                 }
2226         }
2227         result = FALSE;
2228         return result;
2229 }
2230
2231
2232 static gboolean gee_linked_list_iterator_real_has_previous (GeeBidirIterator* base) {
2233         GeeLinkedListIterator * self;
2234         gboolean result = FALSE;
2235         gint _tmp0_;
2236         GeeLinkedList* _tmp1_;
2237         gint _tmp2_;
2238         gboolean _tmp3_;
2239         self = (GeeLinkedListIterator*) base;
2240         _tmp0_ = self->priv->_stamp;
2241         _tmp1_ = self->priv->_list;
2242         _tmp2_ = _tmp1_->priv->_stamp;
2243         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2244         _tmp3_ = self->priv->started;
2245         if (!_tmp3_) {
2246                 result = FALSE;
2247                 return result;
2248         } else {
2249                 GeeLinkedListNode* _tmp4_;
2250                 _tmp4_ = self->priv->position;
2251                 if (_tmp4_ != NULL) {
2252                         GeeLinkedListNode* _tmp5_;
2253                         GeeLinkedListNode* _tmp6_;
2254                         _tmp5_ = self->priv->position;
2255                         _tmp6_ = _tmp5_->prev;
2256                         result = _tmp6_ != NULL;
2257                         return result;
2258                 }
2259         }
2260         result = FALSE;
2261         return result;
2262 }
2263
2264
2265 static gboolean gee_linked_list_iterator_real_last (GeeBidirIterator* base) {
2266         GeeLinkedListIterator * self;
2267         gboolean result = FALSE;
2268         gint _tmp0_;
2269         GeeLinkedList* _tmp1_;
2270         gint _tmp2_;
2271         GeeLinkedList* _tmp3_;
2272         gint _tmp4_;
2273         gint _tmp5_;
2274         GeeLinkedList* _tmp6_;
2275         GeeLinkedListNode* _tmp7_;
2276         GeeLinkedList* _tmp8_;
2277         gint _tmp9_;
2278         GeeLinkedListNode* _tmp10_;
2279         self = (GeeLinkedListIterator*) base;
2280         _tmp0_ = self->priv->_stamp;
2281         _tmp1_ = self->priv->_list;
2282         _tmp2_ = _tmp1_->priv->_stamp;
2283         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2284         _tmp3_ = self->priv->_list;
2285         _tmp4_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp3_);
2286         _tmp5_ = _tmp4_;
2287         if (_tmp5_ == 0) {
2288                 result = FALSE;
2289                 return result;
2290         }
2291         _tmp6_ = self->priv->_list;
2292         _tmp7_ = _tmp6_->priv->_tail;
2293         self->priv->position = _tmp7_;
2294         self->priv->started = TRUE;
2295         _tmp8_ = self->priv->_list;
2296         _tmp9_ = _tmp8_->priv->_size;
2297         self->priv->_index = _tmp9_ - 1;
2298         _tmp10_ = self->priv->position;
2299         result = _tmp10_ != NULL;
2300         return result;
2301 }
2302
2303
2304 static void gee_linked_list_iterator_real_set (GeeListIterator* base, gconstpointer item) {
2305         GeeLinkedListIterator * self;
2306         gint _tmp0_;
2307         GeeLinkedList* _tmp1_;
2308         gint _tmp2_;
2309         GeeLinkedListNode* _tmp3_;
2310         GeeLinkedListNode* _tmp4_;
2311         gconstpointer _tmp5_;
2312         gpointer _tmp6_;
2313         self = (GeeLinkedListIterator*) base;
2314         _tmp0_ = self->priv->_stamp;
2315         _tmp1_ = self->priv->_list;
2316         _tmp2_ = _tmp1_->priv->_stamp;
2317         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2318         _tmp3_ = self->priv->position;
2319         _vala_assert (_tmp3_ != NULL, "this.position != null");
2320         _tmp4_ = self->priv->position;
2321         _tmp5_ = item;
2322         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
2323         ((_tmp4_->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp4_->data = (self->priv->g_destroy_func (_tmp4_->data), NULL));
2324         _tmp4_->data = _tmp6_;
2325 }
2326
2327
2328 static void gee_linked_list_iterator_real_insert (GeeBidirListIterator* base, gconstpointer item) {
2329         GeeLinkedListIterator * self;
2330         gint _tmp0_;
2331         GeeLinkedList* _tmp1_;
2332         gint _tmp2_;
2333         GeeLinkedListNode* _tmp3_;
2334         gconstpointer _tmp4_;
2335         gpointer _tmp5_;
2336         GeeLinkedListNode* _tmp6_;
2337         GeeLinkedListNode* n;
2338         GeeLinkedListNode* _tmp7_;
2339         GeeLinkedListNode* _tmp8_;
2340         GeeLinkedList* _tmp31_;
2341         gint _tmp32_;
2342         gint _tmp33_;
2343         GeeLinkedList* _tmp34_;
2344         gint _tmp35_;
2345         self = (GeeLinkedListIterator*) base;
2346         _tmp0_ = self->priv->_stamp;
2347         _tmp1_ = self->priv->_list;
2348         _tmp2_ = _tmp1_->priv->_stamp;
2349         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2350         _tmp3_ = self->priv->position;
2351         _vala_assert (_tmp3_ != NULL, "this.position != null");
2352         _tmp4_ = item;
2353         _tmp5_ = ((_tmp4_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp4_) : ((gpointer) _tmp4_);
2354         _tmp6_ = gee_linked_list_node_new (_tmp5_);
2355         n = _tmp6_;
2356         _tmp7_ = self->priv->position;
2357         _tmp8_ = _tmp7_->prev;
2358         if (_tmp8_ != NULL) {
2359                 GeeLinkedListNode* _tmp9_;
2360                 GeeLinkedListNode* _tmp10_;
2361                 GeeLinkedListNode* _tmp11_;
2362                 GeeLinkedListNode* position;
2363                 GeeLinkedListNode* _tmp12_;
2364                 GeeLinkedListNode* _tmp13_;
2365                 GeeLinkedListNode* _tmp14_;
2366                 GeeLinkedListNode* _tmp15_;
2367                 GeeLinkedListNode* _tmp16_;
2368                 GeeLinkedListNode* _tmp17_;
2369                 GeeLinkedListNode* _tmp18_;
2370                 GeeLinkedListNode* _tmp19_;
2371                 GeeLinkedListNode* _n;
2372                 GeeLinkedListNode* _tmp20_;
2373                 GeeLinkedListNode* _tmp21_;
2374                 GeeLinkedListNode* _tmp22_;
2375                 _tmp9_ = self->priv->position;
2376                 _tmp10_ = _tmp9_->prev;
2377                 _tmp11_ = _tmp10_->next;
2378                 _tmp10_->next = NULL;
2379                 position = _tmp11_;
2380                 _tmp12_ = n;
2381                 _tmp13_ = position;
2382                 _tmp14_ = _tmp13_->prev;
2383                 _tmp12_->prev = _tmp14_;
2384                 _tmp15_ = position;
2385                 _tmp16_ = n;
2386                 _tmp15_->prev = _tmp16_;
2387                 _tmp17_ = n;
2388                 _tmp18_ = position;
2389                 position = NULL;
2390                 _gee_linked_list_node_free0 (_tmp17_->next);
2391                 _tmp17_->next = _tmp18_;
2392                 _tmp19_ = n;
2393                 _n = _tmp19_;
2394                 _tmp20_ = _n;
2395                 _tmp21_ = _tmp20_->prev;
2396                 _tmp22_ = n;
2397                 n = NULL;
2398                 _gee_linked_list_node_free0 (_tmp21_->next);
2399                 _tmp21_->next = _tmp22_;
2400                 _gee_linked_list_node_free0 (position);
2401         } else {
2402                 GeeLinkedList* _tmp23_;
2403                 GeeLinkedListNode* _tmp24_;
2404                 GeeLinkedListNode* position;
2405                 GeeLinkedListNode* _tmp25_;
2406                 GeeLinkedListNode* _tmp26_;
2407                 GeeLinkedListNode* _tmp27_;
2408                 GeeLinkedListNode* _tmp28_;
2409                 GeeLinkedList* _tmp29_;
2410                 GeeLinkedListNode* _tmp30_;
2411                 _tmp23_ = self->priv->_list;
2412                 _tmp24_ = _tmp23_->priv->_head;
2413                 _tmp23_->priv->_head = NULL;
2414                 position = _tmp24_;
2415                 _tmp25_ = position;
2416                 _tmp26_ = n;
2417                 _tmp25_->prev = _tmp26_;
2418                 _tmp27_ = n;
2419                 _tmp28_ = position;
2420                 position = NULL;
2421                 _gee_linked_list_node_free0 (_tmp27_->next);
2422                 _tmp27_->next = _tmp28_;
2423                 _tmp29_ = self->priv->_list;
2424                 _tmp30_ = n;
2425                 n = NULL;
2426                 _gee_linked_list_node_free0 (_tmp29_->priv->_head);
2427                 _tmp29_->priv->_head = _tmp30_;
2428                 _gee_linked_list_node_free0 (position);
2429         }
2430         _tmp31_ = self->priv->_list;
2431         _tmp32_ = _tmp31_->priv->_size;
2432         _tmp31_->priv->_size = _tmp32_ + 1;
2433         _tmp33_ = self->priv->_index;
2434         self->priv->_index = _tmp33_ + 1;
2435         _tmp34_ = self->priv->_list;
2436         _tmp35_ = _tmp34_->priv->_stamp;
2437         self->priv->_stamp = _tmp35_;
2438         _gee_linked_list_node_free0 (n);
2439 }
2440
2441
2442 static void gee_linked_list_iterator_real_add (GeeListIterator* base, gconstpointer item) {
2443         GeeLinkedListIterator * self;
2444         gint _tmp0_;
2445         GeeLinkedList* _tmp1_;
2446         gint _tmp2_;
2447         GeeLinkedListNode* _tmp3_;
2448         gconstpointer _tmp4_;
2449         gpointer _tmp5_;
2450         GeeLinkedListNode* _tmp6_;
2451         GeeLinkedListNode* n;
2452         GeeLinkedListNode* _tmp7_;
2453         GeeLinkedListNode* _tmp8_;
2454         GeeLinkedListNode* _tmp17_;
2455         GeeLinkedListNode* _tmp18_;
2456         GeeLinkedListNode* _tmp19_;
2457         GeeLinkedListNode* _tmp20_;
2458         GeeLinkedListNode* _tmp21_;
2459         GeeLinkedListNode* _tmp22_;
2460         GeeLinkedListNode* _tmp23_;
2461         GeeLinkedList* _tmp24_;
2462         gint _tmp25_;
2463         gint _tmp26_;
2464         GeeLinkedList* _tmp27_;
2465         gint _tmp28_;
2466         self = (GeeLinkedListIterator*) base;
2467         _tmp0_ = self->priv->_stamp;
2468         _tmp1_ = self->priv->_list;
2469         _tmp2_ = _tmp1_->priv->_stamp;
2470         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2471         _tmp3_ = self->priv->position;
2472         _vala_assert (_tmp3_ != NULL, "this.position != null");
2473         _tmp4_ = item;
2474         _tmp5_ = ((_tmp4_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp4_) : ((gpointer) _tmp4_);
2475         _tmp6_ = gee_linked_list_node_new (_tmp5_);
2476         n = _tmp6_;
2477         _tmp7_ = self->priv->position;
2478         _tmp8_ = _tmp7_->next;
2479         if (_tmp8_ != NULL) {
2480                 GeeLinkedListNode* _tmp9_;
2481                 GeeLinkedListNode* _tmp10_;
2482                 GeeLinkedListNode* _tmp11_;
2483                 GeeLinkedListNode* _tmp12_;
2484                 GeeLinkedListNode* _tmp13_;
2485                 GeeLinkedListNode* _tmp14_;
2486                 _tmp9_ = self->priv->position;
2487                 _tmp10_ = _tmp9_->next;
2488                 _tmp11_ = n;
2489                 _tmp10_->prev = _tmp11_;
2490                 _tmp12_ = n;
2491                 _tmp13_ = self->priv->position;
2492                 _tmp14_ = _tmp13_->next;
2493                 _tmp13_->next = NULL;
2494                 _gee_linked_list_node_free0 (_tmp12_->next);
2495                 _tmp12_->next = _tmp14_;
2496         } else {
2497                 GeeLinkedList* _tmp15_;
2498                 GeeLinkedListNode* _tmp16_;
2499                 _tmp15_ = self->priv->_list;
2500                 _tmp16_ = n;
2501                 _tmp15_->priv->_tail = _tmp16_;
2502         }
2503         _tmp17_ = self->priv->position;
2504         _tmp18_ = n;
2505         n = NULL;
2506         _gee_linked_list_node_free0 (_tmp17_->next);
2507         _tmp17_->next = _tmp18_;
2508         _tmp19_ = self->priv->position;
2509         _tmp20_ = _tmp19_->next;
2510         _tmp21_ = self->priv->position;
2511         _tmp20_->prev = _tmp21_;
2512         _tmp22_ = self->priv->position;
2513         _tmp23_ = _tmp22_->next;
2514         self->priv->position = _tmp23_;
2515         _tmp24_ = self->priv->_list;
2516         _tmp25_ = _tmp24_->priv->_size;
2517         _tmp24_->priv->_size = _tmp25_ + 1;
2518         _tmp26_ = self->priv->_index;
2519         self->priv->_index = _tmp26_ + 1;
2520         _tmp27_ = self->priv->_list;
2521         _tmp28_ = _tmp27_->priv->_stamp;
2522         self->priv->_stamp = _tmp28_;
2523         _gee_linked_list_node_free0 (n);
2524 }
2525
2526
2527 static gint gee_linked_list_iterator_real_index (GeeListIterator* base) {
2528         GeeLinkedListIterator * self;
2529         gint result = 0;
2530         gint _tmp0_;
2531         GeeLinkedList* _tmp1_;
2532         gint _tmp2_;
2533         GeeLinkedListNode* _tmp3_;
2534         gint _tmp4_;
2535         self = (GeeLinkedListIterator*) base;
2536         _tmp0_ = self->priv->_stamp;
2537         _tmp1_ = self->priv->_list;
2538         _tmp2_ = _tmp1_->priv->_stamp;
2539         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2540         _tmp3_ = self->priv->position;
2541         _vala_assert (_tmp3_ != NULL, "this.position != null");
2542         _tmp4_ = self->priv->_index;
2543         result = _tmp4_;
2544         return result;
2545 }
2546
2547
2548 static gboolean gee_linked_list_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
2549         GeeLinkedListIterator * self;
2550         gboolean result = FALSE;
2551         gint _tmp0_;
2552         GeeLinkedList* _tmp1_;
2553         gint _tmp2_;
2554         gboolean _tmp3_;
2555         GeeLinkedList* _tmp15_;
2556         GeeLinkedListNode* _tmp16_;
2557         self = (GeeLinkedListIterator*) base;
2558         _tmp0_ = self->priv->_stamp;
2559         _tmp1_ = self->priv->_list;
2560         _tmp2_ = _tmp1_->priv->_stamp;
2561         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _list._stamp");
2562         _tmp3_ = self->priv->started;
2563         if (!_tmp3_) {
2564                 GeeLinkedList* _tmp4_;
2565                 GeeLinkedListNode* _tmp5_;
2566                 GeeLinkedListNode* _tmp6_;
2567                 _tmp4_ = self->priv->_list;
2568                 _tmp5_ = _tmp4_->priv->_head;
2569                 self->priv->position = _tmp5_;
2570                 _tmp6_ = self->priv->position;
2571                 if (_tmp6_ != NULL) {
2572                         self->priv->started = TRUE;
2573                 }
2574         }
2575         self->priv->removed = FALSE;
2576         while (TRUE) {
2577                 GeeLinkedListNode* _tmp7_;
2578                 GeeForallFunc _tmp8_;
2579                 void* _tmp8__target;
2580                 GeeLinkedListNode* _tmp9_;
2581                 gconstpointer _tmp10_;
2582                 gpointer _tmp11_;
2583                 gboolean _tmp12_ = FALSE;
2584                 GeeLinkedListNode* _tmp13_;
2585                 GeeLinkedListNode* _tmp14_;
2586                 _tmp7_ = self->priv->position;
2587                 if (!(_tmp7_ != NULL)) {
2588                         break;
2589                 }
2590                 _tmp8_ = f;
2591                 _tmp8__target = f_target;
2592                 _tmp9_ = self->priv->position;
2593                 _tmp10_ = _tmp9_->data;
2594                 _tmp11_ = ((_tmp10_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp10_) : ((gpointer) _tmp10_);
2595                 _tmp12_ = _tmp8_ (_tmp11_, _tmp8__target);
2596                 if (!_tmp12_) {
2597                         result = FALSE;
2598                         return result;
2599                 }
2600                 _tmp13_ = self->priv->position;
2601                 _tmp14_ = _tmp13_->next;
2602                 self->priv->position = _tmp14_;
2603         }
2604         _tmp15_ = self->priv->_list;
2605         _tmp16_ = _tmp15_->priv->_tail;
2606         self->priv->position = _tmp16_;
2607         result = TRUE;
2608         return result;
2609 }
2610
2611
2612 static gboolean gee_linked_list_iterator_real_get_read_only (GeeIterator* base) {
2613         gboolean result;
2614         GeeLinkedListIterator* self;
2615         self = (GeeLinkedListIterator*) base;
2616         result = FALSE;
2617         return result;
2618 }
2619
2620
2621 static gboolean gee_linked_list_iterator_real_get_valid (GeeIterator* base) {
2622         gboolean result;
2623         GeeLinkedListIterator* self;
2624         gboolean _tmp0_ = FALSE;
2625         gboolean _tmp1_;
2626         gboolean _tmp3_;
2627         self = (GeeLinkedListIterator*) base;
2628         _tmp1_ = self->priv->removed;
2629         if (!_tmp1_) {
2630                 GeeLinkedListNode* _tmp2_;
2631                 _tmp2_ = self->priv->position;
2632                 _tmp0_ = _tmp2_ != NULL;
2633         } else {
2634                 _tmp0_ = FALSE;
2635         }
2636         _tmp3_ = _tmp0_;
2637         result = _tmp3_;
2638         return result;
2639 }
2640
2641
2642 static void gee_linked_list_iterator_class_init (GeeLinkedListIteratorClass * klass) {
2643         gee_linked_list_iterator_parent_class = g_type_class_peek_parent (klass);
2644         g_type_class_add_private (klass, sizeof (GeeLinkedListIteratorPrivate));
2645         G_OBJECT_CLASS (klass)->get_property = _vala_gee_linked_list_iterator_get_property;
2646         G_OBJECT_CLASS (klass)->set_property = _vala_gee_linked_list_iterator_set_property;
2647         G_OBJECT_CLASS (klass)->finalize = gee_linked_list_iterator_finalize;
2648         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2649         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2650         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2651         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2652         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2653 }
2654
2655
2656 static GType gee_linked_list_iterator_gee_traversable_get_g_type (GeeLinkedListIterator* self) {
2657         return self->priv->g_type;
2658 }
2659
2660
2661 static GBoxedCopyFunc gee_linked_list_iterator_gee_traversable_get_g_dup_func (GeeLinkedListIterator* self) {
2662         return self->priv->g_dup_func;
2663 }
2664
2665
2666 static GDestroyNotify gee_linked_list_iterator_gee_traversable_get_g_destroy_func (GeeLinkedListIterator* self) {
2667         return self->priv->g_destroy_func;
2668 }
2669
2670
2671 static void gee_linked_list_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
2672         gee_linked_list_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
2673         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_linked_list_iterator_real_foreach;
2674         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_linked_list_iterator_gee_traversable_get_g_type;
2675         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_linked_list_iterator_gee_traversable_get_g_dup_func;
2676         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_linked_list_iterator_gee_traversable_get_g_destroy_func;
2677 }
2678
2679
2680 static void gee_linked_list_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
2681         gee_linked_list_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
2682         iface->next = (gboolean (*)(GeeIterator*)) gee_linked_list_iterator_real_next;
2683         iface->has_next = (gboolean (*)(GeeIterator*)) gee_linked_list_iterator_real_has_next;
2684         iface->get = (gpointer (*)(GeeIterator*)) gee_linked_list_iterator_real_get;
2685         iface->remove = (void (*)(GeeIterator*)) gee_linked_list_iterator_real_remove;
2686         iface->get_read_only = gee_linked_list_iterator_real_get_read_only;
2687         iface->get_valid = gee_linked_list_iterator_real_get_valid;
2688 }
2689
2690
2691 static GType gee_linked_list_iterator_gee_bidir_iterator_get_g_type (GeeLinkedListIterator* self) {
2692         return self->priv->g_type;
2693 }
2694
2695
2696 static GBoxedCopyFunc gee_linked_list_iterator_gee_bidir_iterator_get_g_dup_func (GeeLinkedListIterator* self) {
2697         return self->priv->g_dup_func;
2698 }
2699
2700
2701 static GDestroyNotify gee_linked_list_iterator_gee_bidir_iterator_get_g_destroy_func (GeeLinkedListIterator* self) {
2702         return self->priv->g_destroy_func;
2703 }
2704
2705
2706 static void gee_linked_list_iterator_gee_bidir_iterator_interface_init (GeeBidirIteratorIface * iface) {
2707         gee_linked_list_iterator_gee_bidir_iterator_parent_iface = g_type_interface_peek_parent (iface);
2708         iface->first = (gboolean (*)(GeeBidirIterator*)) gee_linked_list_iterator_real_first;
2709         iface->previous = (gboolean (*)(GeeBidirIterator*)) gee_linked_list_iterator_real_previous;
2710         iface->has_previous = (gboolean (*)(GeeBidirIterator*)) gee_linked_list_iterator_real_has_previous;
2711         iface->last = (gboolean (*)(GeeBidirIterator*)) gee_linked_list_iterator_real_last;
2712         iface->get_g_type = (GType(*)(GeeBidirIterator*)) gee_linked_list_iterator_gee_bidir_iterator_get_g_type;
2713         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeBidirIterator*)) gee_linked_list_iterator_gee_bidir_iterator_get_g_dup_func;
2714         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeBidirIterator*)) gee_linked_list_iterator_gee_bidir_iterator_get_g_destroy_func;
2715 }
2716
2717
2718 static void gee_linked_list_iterator_gee_list_iterator_interface_init (GeeListIteratorIface * iface) {
2719         gee_linked_list_iterator_gee_list_iterator_parent_iface = g_type_interface_peek_parent (iface);
2720         iface->set = (void (*)(GeeListIterator*, gconstpointer)) gee_linked_list_iterator_real_set;
2721         iface->add = (void (*)(GeeListIterator*, gconstpointer)) gee_linked_list_iterator_real_add;
2722         iface->index = (gint (*)(GeeListIterator*)) gee_linked_list_iterator_real_index;
2723 }
2724
2725
2726 static GType gee_linked_list_iterator_gee_bidir_list_iterator_get_g_type (GeeLinkedListIterator* self) {
2727         return self->priv->g_type;
2728 }
2729
2730
2731 static GBoxedCopyFunc gee_linked_list_iterator_gee_bidir_list_iterator_get_g_dup_func (GeeLinkedListIterator* self) {
2732         return self->priv->g_dup_func;
2733 }
2734
2735
2736 static GDestroyNotify gee_linked_list_iterator_gee_bidir_list_iterator_get_g_destroy_func (GeeLinkedListIterator* self) {
2737         return self->priv->g_destroy_func;
2738 }
2739
2740
2741 static void gee_linked_list_iterator_gee_bidir_list_iterator_interface_init (GeeBidirListIteratorIface * iface) {
2742         gee_linked_list_iterator_gee_bidir_list_iterator_parent_iface = g_type_interface_peek_parent (iface);
2743         iface->insert = (void (*)(GeeBidirListIterator*, gconstpointer)) gee_linked_list_iterator_real_insert;
2744         iface->get_g_type = (GType(*)(GeeBidirListIterator*)) gee_linked_list_iterator_gee_bidir_list_iterator_get_g_type;
2745         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeBidirListIterator*)) gee_linked_list_iterator_gee_bidir_list_iterator_get_g_dup_func;
2746         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeBidirListIterator*)) gee_linked_list_iterator_gee_bidir_list_iterator_get_g_destroy_func;
2747 }
2748
2749
2750 static void gee_linked_list_iterator_instance_init (GeeLinkedListIterator * self) {
2751         self->priv = GEE_LINKED_LIST_ITERATOR_GET_PRIVATE (self);
2752         self->priv->started = FALSE;
2753         self->priv->removed = FALSE;
2754 }
2755
2756
2757 static void gee_linked_list_iterator_finalize (GObject* obj) {
2758         GeeLinkedListIterator * self;
2759         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator);
2760         _g_object_unref0 (self->priv->_list);
2761         G_OBJECT_CLASS (gee_linked_list_iterator_parent_class)->finalize (obj);
2762 }
2763
2764
2765 static GType gee_linked_list_iterator_get_type (void) {
2766         static volatile gsize gee_linked_list_iterator_type_id__volatile = 0;
2767         if (g_once_init_enter (&gee_linked_list_iterator_type_id__volatile)) {
2768                 static const GTypeInfo g_define_type_info = { sizeof (GeeLinkedListIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_linked_list_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeLinkedListIterator), 0, (GInstanceInitFunc) gee_linked_list_iterator_instance_init, NULL };
2769                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2770                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2771                 static const GInterfaceInfo gee_bidir_iterator_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_bidir_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2772                 static const GInterfaceInfo gee_list_iterator_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_list_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2773                 static const GInterfaceInfo gee_bidir_list_iterator_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_bidir_list_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2774                 GType gee_linked_list_iterator_type_id;
2775                 gee_linked_list_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeLinkedListIterator", &g_define_type_info, 0);
2776                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
2777                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
2778                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_BIDIR_ITERATOR, &gee_bidir_iterator_info);
2779                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_LIST_ITERATOR, &gee_list_iterator_info);
2780                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_BIDIR_LIST_ITERATOR, &gee_bidir_list_iterator_info);
2781                 g_once_init_leave (&gee_linked_list_iterator_type_id__volatile, gee_linked_list_iterator_type_id);
2782         }
2783         return gee_linked_list_iterator_type_id__volatile;
2784 }
2785
2786
2787 static void _vala_gee_linked_list_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2788         GeeLinkedListIterator * self;
2789         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator);
2790         switch (property_id) {
2791                 case GEE_LINKED_LIST_ITERATOR_READ_ONLY:
2792                 g_value_set_boolean (value, gee_iterator_get_read_only ((GeeIterator*) self));
2793                 break;
2794                 case GEE_LINKED_LIST_ITERATOR_VALID:
2795                 g_value_set_boolean (value, gee_iterator_get_valid ((GeeIterator*) self));
2796                 break;
2797                 default:
2798                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2799                 break;
2800         }
2801 }
2802
2803
2804 static void _vala_gee_linked_list_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2805         GeeLinkedListIterator * self;
2806         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator);
2807         switch (property_id) {
2808                 case GEE_LINKED_LIST_ITERATOR_G_TYPE:
2809                 self->priv->g_type = g_value_get_gtype (value);
2810                 break;
2811                 case GEE_LINKED_LIST_ITERATOR_G_DUP_FUNC:
2812                 self->priv->g_dup_func = g_value_get_pointer (value);
2813                 break;
2814                 case GEE_LINKED_LIST_ITERATOR_G_DESTROY_FUNC:
2815                 self->priv->g_destroy_func = g_value_get_pointer (value);
2816                 break;
2817                 default:
2818                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2819                 break;
2820         }
2821 }
2822
2823
2824 static void gee_linked_list_class_init (GeeLinkedListClass * klass) {
2825         gee_linked_list_parent_class = g_type_class_peek_parent (klass);
2826         g_type_class_add_private (klass, sizeof (GeeLinkedListPrivate));
2827         GEE_ABSTRACT_COLLECTION_CLASS (klass)->foreach = gee_linked_list_real_foreach;
2828         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_linked_list_real_iterator;
2829         GEE_ABSTRACT_LIST_CLASS (klass)->list_iterator = gee_linked_list_real_list_iterator;
2830         GEE_ABSTRACT_BIDIR_LIST_CLASS (klass)->bidir_list_iterator = gee_linked_list_real_bidir_list_iterator;
2831         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_linked_list_real_contains;
2832         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_linked_list_real_add;
2833         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_linked_list_real_remove;
2834         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_linked_list_real_clear;
2835         GEE_ABSTRACT_LIST_CLASS (klass)->get = gee_linked_list_real_get;
2836         GEE_ABSTRACT_LIST_CLASS (klass)->set = gee_linked_list_real_set;
2837         GEE_ABSTRACT_LIST_CLASS (klass)->index_of = gee_linked_list_real_index_of;
2838         GEE_ABSTRACT_LIST_CLASS (klass)->insert = gee_linked_list_real_insert;
2839         GEE_ABSTRACT_LIST_CLASS (klass)->remove_at = gee_linked_list_real_remove_at;
2840         GEE_ABSTRACT_LIST_CLASS (klass)->slice = gee_linked_list_real_slice;
2841         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_linked_list_real_get_size;
2842         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_linked_list_real_get_read_only;
2843         G_OBJECT_CLASS (klass)->get_property = _vala_gee_linked_list_get_property;
2844         G_OBJECT_CLASS (klass)->set_property = _vala_gee_linked_list_set_property;
2845         G_OBJECT_CLASS (klass)->finalize = gee_linked_list_finalize;
2846         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2847         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2848         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2849         /**
2850          * {@inheritDoc}
2851          */
2852         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2853         /**
2854          * {@inheritDoc}
2855          */
2856         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_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));
2857         /**
2858          * {@inheritDoc}
2859          */
2860         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_CAPACITY, g_param_spec_int ("capacity", "capacity", "capacity", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2861         /**
2862          * {@inheritDoc}
2863          */
2864         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_REMAINING_CAPACITY, g_param_spec_int ("remaining-capacity", "remaining-capacity", "remaining-capacity", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2865         /**
2866          * {@inheritDoc}
2867          */
2868         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_IS_FULL, g_param_spec_boolean ("is-full", "is-full", "is-full", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2869 }
2870
2871
2872 static GType gee_linked_list_gee_queue_get_g_type (GeeLinkedList* self) {
2873         return self->priv->g_type;
2874 }
2875
2876
2877 static GBoxedCopyFunc gee_linked_list_gee_queue_get_g_dup_func (GeeLinkedList* self) {
2878         return self->priv->g_dup_func;
2879 }
2880
2881
2882 static GDestroyNotify gee_linked_list_gee_queue_get_g_destroy_func (GeeLinkedList* self) {
2883         return self->priv->g_destroy_func;
2884 }
2885
2886
2887 static void gee_linked_list_gee_queue_interface_init (GeeQueueIface * iface) {
2888         gee_linked_list_gee_queue_parent_iface = g_type_interface_peek_parent (iface);
2889         iface->offer = (gboolean (*)(GeeQueue*, gconstpointer)) gee_linked_list_real_offer;
2890         iface->peek = (gpointer (*)(GeeQueue*)) gee_linked_list_real_peek;
2891         iface->poll = (gpointer (*)(GeeQueue*)) gee_linked_list_real_poll;
2892         iface->drain = (gint (*)(GeeQueue*, GeeCollection*, gint)) gee_linked_list_real_drain;
2893         iface->get_g_type = (GType(*)(GeeQueue*)) gee_linked_list_gee_queue_get_g_type;
2894         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeQueue*)) gee_linked_list_gee_queue_get_g_dup_func;
2895         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeQueue*)) gee_linked_list_gee_queue_get_g_destroy_func;
2896         iface->get_capacity = gee_linked_list_real_get_capacity;
2897         iface->get_remaining_capacity = gee_linked_list_real_get_remaining_capacity;
2898         iface->get_is_full = gee_linked_list_real_get_is_full;
2899 }
2900
2901
2902 static GType gee_linked_list_gee_deque_get_g_type (GeeLinkedList* self) {
2903         return self->priv->g_type;
2904 }
2905
2906
2907 static GBoxedCopyFunc gee_linked_list_gee_deque_get_g_dup_func (GeeLinkedList* self) {
2908         return self->priv->g_dup_func;
2909 }
2910
2911
2912 static GDestroyNotify gee_linked_list_gee_deque_get_g_destroy_func (GeeLinkedList* self) {
2913         return self->priv->g_destroy_func;
2914 }
2915
2916
2917 static void gee_linked_list_gee_deque_interface_init (GeeDequeIface * iface) {
2918         gee_linked_list_gee_deque_parent_iface = g_type_interface_peek_parent (iface);
2919         iface->offer_head = (gboolean (*)(GeeDeque*, gconstpointer)) gee_linked_list_real_offer_head;
2920         iface->peek_head = (gpointer (*)(GeeDeque*)) gee_linked_list_real_peek_head;
2921         iface->poll_head = (gpointer (*)(GeeDeque*)) gee_linked_list_real_poll_head;
2922         iface->drain_head = (gint (*)(GeeDeque*, GeeCollection*, gint)) gee_linked_list_real_drain_head;
2923         iface->offer_tail = (gboolean (*)(GeeDeque*, gconstpointer)) gee_linked_list_real_offer_tail;
2924         iface->peek_tail = (gpointer (*)(GeeDeque*)) gee_linked_list_real_peek_tail;
2925         iface->poll_tail = (gpointer (*)(GeeDeque*)) gee_linked_list_real_poll_tail;
2926         iface->drain_tail = (gint (*)(GeeDeque*, GeeCollection*, gint)) gee_linked_list_real_drain_tail;
2927         iface->get_g_type = (GType(*)(GeeDeque*)) gee_linked_list_gee_deque_get_g_type;
2928         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeDeque*)) gee_linked_list_gee_deque_get_g_dup_func;
2929         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeDeque*)) gee_linked_list_gee_deque_get_g_destroy_func;
2930 }
2931
2932
2933 static void gee_linked_list_instance_init (GeeLinkedList * self) {
2934         self->priv = GEE_LINKED_LIST_GET_PRIVATE (self);
2935         self->priv->_size = 0;
2936         self->priv->_stamp = 0;
2937         self->priv->_head = NULL;
2938         self->priv->_tail = NULL;
2939 }
2940
2941
2942 static void gee_linked_list_finalize (GObject* obj) {
2943         GeeLinkedList * self;
2944         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_LINKED_LIST, GeeLinkedList);
2945         gee_abstract_collection_clear ((GeeAbstractCollection*) self);
2946         _gee_linked_list_node_free0 (self->priv->_head);
2947         (self->priv->_equal_func_target_destroy_notify == NULL) ? NULL : (self->priv->_equal_func_target_destroy_notify (self->priv->_equal_func_target), NULL);
2948         self->priv->_equal_func = NULL;
2949         self->priv->_equal_func_target = NULL;
2950         self->priv->_equal_func_target_destroy_notify = NULL;
2951         G_OBJECT_CLASS (gee_linked_list_parent_class)->finalize (obj);
2952 }
2953
2954
2955 /**
2956  * Doubly-linked list implementation of the {@link List} interface.
2957  *
2958  * This implementation is pretty well designed for highly mutable data. When
2959  * indexed access is privileged prefer using {@link ArrayList}.
2960  *
2961  * @see ArrayList
2962  */
2963 GType gee_linked_list_get_type (void) {
2964         static volatile gsize gee_linked_list_type_id__volatile = 0;
2965         if (g_once_init_enter (&gee_linked_list_type_id__volatile)) {
2966                 static const GTypeInfo g_define_type_info = { sizeof (GeeLinkedListClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_linked_list_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeLinkedList), 0, (GInstanceInitFunc) gee_linked_list_instance_init, NULL };
2967                 static const GInterfaceInfo gee_queue_info = { (GInterfaceInitFunc) gee_linked_list_gee_queue_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2968                 static const GInterfaceInfo gee_deque_info = { (GInterfaceInitFunc) gee_linked_list_gee_deque_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2969                 GType gee_linked_list_type_id;
2970                 gee_linked_list_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_BIDIR_LIST, "GeeLinkedList", &g_define_type_info, 0);
2971                 g_type_add_interface_static (gee_linked_list_type_id, GEE_TYPE_QUEUE, &gee_queue_info);
2972                 g_type_add_interface_static (gee_linked_list_type_id, GEE_TYPE_DEQUE, &gee_deque_info);
2973                 g_once_init_leave (&gee_linked_list_type_id__volatile, gee_linked_list_type_id);
2974         }
2975         return gee_linked_list_type_id__volatile;
2976 }
2977
2978
2979 static void _vala_gee_linked_list_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2980         GeeLinkedList * self;
2981         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_LINKED_LIST, GeeLinkedList);
2982         switch (property_id) {
2983                 case GEE_LINKED_LIST_SIZE:
2984                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
2985                 break;
2986                 case GEE_LINKED_LIST_READ_ONLY:
2987                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
2988                 break;
2989                 case GEE_LINKED_LIST_CAPACITY:
2990                 g_value_set_int (value, gee_queue_get_capacity ((GeeQueue*) self));
2991                 break;
2992                 case GEE_LINKED_LIST_REMAINING_CAPACITY:
2993                 g_value_set_int (value, gee_queue_get_remaining_capacity ((GeeQueue*) self));
2994                 break;
2995                 case GEE_LINKED_LIST_IS_FULL:
2996                 g_value_set_boolean (value, gee_queue_get_is_full ((GeeQueue*) self));
2997                 break;
2998                 default:
2999                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3000                 break;
3001         }
3002 }
3003
3004
3005 static void _vala_gee_linked_list_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3006         GeeLinkedList * self;
3007         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_LINKED_LIST, GeeLinkedList);
3008         switch (property_id) {
3009                 case GEE_LINKED_LIST_G_TYPE:
3010                 self->priv->g_type = g_value_get_gtype (value);
3011                 break;
3012                 case GEE_LINKED_LIST_G_DUP_FUNC:
3013                 self->priv->g_dup_func = g_value_get_pointer (value);
3014                 break;
3015                 case GEE_LINKED_LIST_G_DESTROY_FUNC:
3016                 self->priv->g_destroy_func = g_value_get_pointer (value);
3017                 break;
3018                 default:
3019                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3020                 break;
3021         }
3022 }
3023
3024
3025