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_ITERABLE (gee_iterable_get_type ())
  35 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  36 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  37 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  38
  39 typedef struct _GeeIterable GeeIterable;
  40 typedef struct _GeeIterableIface GeeIterableIface;
  41
  42 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  43 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  44 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  45 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  46
  47 typedef struct _GeeIterator GeeIterator;
  48 typedef struct _GeeIteratorIface GeeIteratorIface;
  49
  50 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  51 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  52 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  53 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  54
  55 typedef struct _GeeCollection GeeCollection;
  56 typedef struct _GeeCollectionIface GeeCollectionIface;
  57
  58 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
  59 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
  60 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  61 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
  62 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
  63 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  64
  65 typedef struct _GeeAbstractCollection GeeAbstractCollection;
  66 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
  67 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
  68
  69 #define GEE_TYPE_LIST (gee_list_get_type ())
  70 #define GEE_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LIST, GeeList))
  71 #define GEE_IS_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LIST))
  72 #define GEE_LIST_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_LIST, GeeListIface))
  73
  74 typedef struct _GeeList GeeList;
  75 typedef struct _GeeListIface GeeListIface;
  76
  77 #define GEE_TYPE_BIDIR_ITERATOR (gee_bidir_iterator_get_type ())
  78 #define GEE_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIterator))
  79 #define GEE_IS_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_BIDIR_ITERATOR))
  80 #define GEE_BIDIR_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIteratorIface))
  81
  82 typedef struct _GeeBidirIterator GeeBidirIterator;
  83 typedef struct _GeeBidirIteratorIface GeeBidirIteratorIface;
  84
  85 #define GEE_TYPE_LIST_ITERATOR (gee_list_iterator_get_type ())
  86 #define GEE_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LIST_ITERATOR, GeeListIterator))
  87 #define GEE_IS_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LIST_ITERATOR))
  88 #define GEE_LIST_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_LIST_ITERATOR, GeeListIteratorIface))
  89
  90 typedef struct _GeeListIterator GeeListIterator;
  91 typedef struct _GeeListIteratorIface GeeListIteratorIface;
  92
  93 #define GEE_TYPE_ABSTRACT_LIST (gee_abstract_list_get_type ())
  94 #define GEE_ABSTRACT_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_LIST, GeeAbstractList))
  95 #define GEE_ABSTRACT_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_LIST, GeeAbstractListClass))
  96 #define GEE_IS_ABSTRACT_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_LIST))
  97 #define GEE_IS_ABSTRACT_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_LIST))
  98 #define GEE_ABSTRACT_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_LIST, GeeAbstractListClass))
  99
 100 typedef struct _GeeAbstractList GeeAbstractList;
 101 typedef struct _GeeAbstractListClass GeeAbstractListClass;
 102 typedef struct _GeeAbstractListPrivate GeeAbstractListPrivate;
 103
 104 #define GEE_TYPE_QUEUE (gee_queue_get_type ())
 105 #define GEE_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_QUEUE, GeeQueue))
 106 #define GEE_IS_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_QUEUE))
 107 #define GEE_QUEUE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_QUEUE, GeeQueueIface))
 108
 109 typedef struct _GeeQueue GeeQueue;
 110 typedef struct _GeeQueueIface GeeQueueIface;
 111
 112 #define GEE_TYPE_DEQUE (gee_deque_get_type ())
 113 #define GEE_DEQUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_DEQUE, GeeDeque))
 114 #define GEE_IS_DEQUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_DEQUE))
 115 #define GEE_DEQUE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_DEQUE, GeeDequeIface))
 116
 117 typedef struct _GeeDeque GeeDeque;
 118 typedef struct _GeeDequeIface GeeDequeIface;
 119
 120 #define GEE_TYPE_LINKED_LIST (gee_linked_list_get_type ())
 121 #define GEE_LINKED_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LINKED_LIST, GeeLinkedList))
 122 #define GEE_LINKED_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LINKED_LIST, GeeLinkedListClass))
 123 #define GEE_IS_LINKED_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LINKED_LIST))
 124 #define GEE_IS_LINKED_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LINKED_LIST))
 125 #define GEE_LINKED_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LINKED_LIST, GeeLinkedListClass))
 126
 127 typedef struct _GeeLinkedList GeeLinkedList;
 128 typedef struct _GeeLinkedListClass GeeLinkedListClass;
 129 typedef struct _GeeLinkedListPrivate GeeLinkedListPrivate;
 130 typedef struct _GeeLinkedListNode GeeLinkedListNode;
 131 #define _gee_linked_list_node_free0(var) ((var == NULL) ? NULL : (var = (gee_linked_list_node_free (var), NULL)))
 132
 133 #define GEE_LINKED_LIST_TYPE_ITERATOR (gee_linked_list_iterator_get_type ())
 134 #define GEE_LINKED_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator))
 135 #define GEE_LINKED_LIST_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIteratorClass))
 136 #define GEE_LINKED_LIST_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_LINKED_LIST_TYPE_ITERATOR))
 137 #define GEE_LINKED_LIST_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_LINKED_LIST_TYPE_ITERATOR))
 138 #define GEE_LINKED_LIST_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIteratorClass))
 139
 140 typedef struct _GeeLinkedListIterator GeeLinkedListIterator;
 141 typedef struct _GeeLinkedListIteratorClass GeeLinkedListIteratorClass;
 142 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 143 typedef struct _GeeLinkedListIteratorPrivate GeeLinkedListIteratorPrivate;
 144 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 145
 146 struct _GeeIteratorIface {
 147         GTypeInterface parent_iface;
 148         gboolean (*next) (GeeIterator* self);
 149         gboolean (*has_next) (GeeIterator* self);
 150         gboolean (*first) (GeeIterator* self);
 151         gpointer (*get) (GeeIterator* self);
 152         void (*remove) (GeeIterator* self);
 153 };
 154
 155 struct _GeeIterableIface {
 156         GTypeInterface parent_iface;
 157         GeeIterator* (*iterator) (GeeIterable* self);
 158         GType (*get_element_type) (GeeIterable* self);
 159 };
 160
 161 struct _GeeCollectionIface {
 162         GTypeInterface parent_iface;
 163         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 164         gboolean (*add) (GeeCollection* self, gconstpointer item);
 165         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 166         void (*clear) (GeeCollection* self);
 167         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 168         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 169         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 170         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 171         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 172         gint (*get_size) (GeeCollection* self);
 173         gboolean (*get_is_empty) (GeeCollection* self);
 174         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 175 };
 176
 177 struct _GeeAbstractCollection {
 178         GObject parent_instance;
 179         GeeAbstractCollectionPrivate * priv;
 180 };
 181
 182 struct _GeeAbstractCollectionClass {
 183         GObjectClass parent_class;
 184         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 185         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 186         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 187         void (*clear) (GeeAbstractCollection* self);
 188         gpointer* (*to_array) (GeeAbstractCollection* self, int* result_length1);
 189         gboolean (*add_all) (GeeAbstractCollection* self, GeeCollection* collection);
 190         gboolean (*contains_all) (GeeAbstractCollection* self, GeeCollection* collection);
 191         gboolean (*remove_all) (GeeAbstractCollection* self, GeeCollection* collection);
 192         gboolean (*retain_all) (GeeAbstractCollection* self, GeeCollection* collection);
 193         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 194         gint (*get_size) (GeeAbstractCollection* self);
 195         gboolean (*get_is_empty) (GeeAbstractCollection* self);
 196         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 197 };
 198
 199 struct _GeeBidirIteratorIface {
 200         GTypeInterface parent_iface;
 201         gboolean (*previous) (GeeBidirIterator* self);
 202         gboolean (*has_previous) (GeeBidirIterator* self);
 203         gboolean (*last) (GeeBidirIterator* self);
 204 };
 205
 206 struct _GeeListIteratorIface {
 207         GTypeInterface parent_iface;
 208         void (*set) (GeeListIterator* self, gconstpointer item);
 209         void (*insert) (GeeListIterator* self, gconstpointer item);
 210         void (*add) (GeeListIterator* self, gconstpointer item);
 211         gint (*index) (GeeListIterator* self);
 212 };
 213
 214 struct _GeeListIface {
 215         GTypeInterface parent_iface;
 216         GeeListIterator* (*list_iterator) (GeeList* self);
 217         gpointer (*get) (GeeList* self, gint index);
 218         void (*set) (GeeList* self, gint index, gconstpointer item);
 219         gint (*index_of) (GeeList* self, gconstpointer item);
 220         void (*insert) (GeeList* self, gint index, gconstpointer item);
 221         gpointer (*remove_at) (GeeList* self, gint index);
 222         GeeList* (*slice) (GeeList* self, gint start, gint stop);
 223         gpointer (*first) (GeeList* self);
 224         gpointer (*last) (GeeList* self);
 225         void (*insert_all) (GeeList* self, gint index, GeeCollection* collection);
 226         void (*sort) (GeeList* self, GCompareFunc compare_func);
 227         GeeList* (*get_read_only_view) (GeeList* self);
 228 };
 229
 230 struct _GeeAbstractList {
 231         GeeAbstractCollection parent_instance;
 232         GeeAbstractListPrivate * priv;
 233 };
 234
 235 struct _GeeAbstractListClass {
 236         GeeAbstractCollectionClass parent_class;
 237         GeeListIterator* (*list_iterator) (GeeAbstractList* self);
 238         gpointer (*get) (GeeAbstractList* self, gint index);
 239         void (*set) (GeeAbstractList* self, gint index, gconstpointer item);
 240         gint (*index_of) (GeeAbstractList* self, gconstpointer item);
 241         void (*insert) (GeeAbstractList* self, gint index, gconstpointer item);
 242         gpointer (*remove_at) (GeeAbstractList* self, gint index);
 243         GeeList* (*slice) (GeeAbstractList* self, gint start, gint stop);
 244         gpointer (*first) (GeeAbstractList* self);
 245         gpointer (*last) (GeeAbstractList* self);
 246         void (*insert_all) (GeeAbstractList* self, gint index, GeeCollection* collection);
 247         GeeList* (*get_read_only_view) (GeeAbstractList* self);
 248 };
 249
 250 struct _GeeQueueIface {
 251         GTypeInterface parent_iface;
 252         gboolean (*offer) (GeeQueue* self, gconstpointer element);
 253         gpointer (*peek) (GeeQueue* self);
 254         gpointer (*poll) (GeeQueue* self);
 255         gint (*drain) (GeeQueue* self, GeeCollection* recipient, gint amount);
 256         gint (*get_capacity) (GeeQueue* self);
 257         gint (*get_remaining_capacity) (GeeQueue* self);
 258         gboolean (*get_is_full) (GeeQueue* self);
 259 };
 260
 261 struct _GeeDequeIface {
 262         GTypeInterface parent_iface;
 263         gboolean (*offer_head) (GeeDeque* self, gconstpointer element);
 264         gpointer (*peek_head) (GeeDeque* self);
 265         gpointer (*poll_head) (GeeDeque* self);
 266         gint (*drain_head) (GeeDeque* self, GeeCollection* recipient, gint amount);
 267         gboolean (*offer_tail) (GeeDeque* self, gconstpointer element);
 268         gpointer (*peek_tail) (GeeDeque* self);
 269         gpointer (*poll_tail) (GeeDeque* self);
 270         gint (*drain_tail) (GeeDeque* self, GeeCollection* recipient, gint amount);
 271 };
 272
 273 struct _GeeLinkedList {
 274         GeeAbstractList parent_instance;
 275         GeeLinkedListPrivate * priv;
 276 };
 277
 278 struct _GeeLinkedListClass {
 279         GeeAbstractListClass parent_class;
 280 };
 281
 282 struct _GeeLinkedListPrivate {
 283         GType g_type;
 284         GBoxedCopyFunc g_dup_func;
 285         GDestroyNotify g_destroy_func;
 286         gint _size;
 287         gint _stamp;
 288         GeeLinkedListNode* _head;
 289         GeeLinkedListNode* _tail;
 290         GEqualFunc _equal_func;
 291 };
 292
 293 struct _GeeLinkedListNode {
 294         gpointer data;
 295         GeeLinkedListNode* prev;
 296         GeeLinkedListNode* next;
 297 };
 298
 299 struct _GeeLinkedListIterator {
 300         GObject parent_instance;
 301         GeeLinkedListIteratorPrivate * priv;
 302 };
 303
 304 struct _GeeLinkedListIteratorClass {
 305         GObjectClass parent_class;
 306 };
 307
 308 struct _GeeLinkedListIteratorPrivate {
 309         GType g_type;
 310         GBoxedCopyFunc g_dup_func;
 311         GDestroyNotify g_destroy_func;
 312         gboolean started;
 313         gboolean removed;
 314         GeeLinkedListNode* position;
 315         gint _stamp;
 316         GeeLinkedList* _list;
 317         gint _index;
 318 };
 319
 320
 321 static gpointer gee_linked_list_parent_class = NULL;
 322 static gpointer gee_linked_list_iterator_parent_class = NULL;
 323 static GeeIteratorIface* gee_linked_list_iterator_gee_iterator_parent_iface = NULL;
 324 static GeeBidirIteratorIface* gee_linked_list_iterator_gee_bidir_iterator_parent_iface = NULL;
 325 static GeeListIteratorIface* gee_linked_list_iterator_gee_list_iterator_parent_iface = NULL;
 326 static GeeQueueIface* gee_linked_list_gee_queue_parent_iface = NULL;
 327 static GeeDequeIface* gee_linked_list_gee_deque_parent_iface = NULL;
 328
 329 GType gee_iterator_get_type (void) G_GNUC_CONST;
 330 GType gee_iterable_get_type (void) G_GNUC_CONST;
 331 GType gee_collection_get_type (void) G_GNUC_CONST;
 332 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 333 GType gee_bidir_iterator_get_type (void) G_GNUC_CONST;
 334 GType gee_list_iterator_get_type (void) G_GNUC_CONST;
 335 GType gee_list_get_type (void) G_GNUC_CONST;
 336 GType gee_abstract_list_get_type (void) G_GNUC_CONST;
 337 GType gee_queue_get_type (void) G_GNUC_CONST;
 338 GType gee_deque_get_type (void) G_GNUC_CONST;
 339 GType gee_linked_list_get_type (void) G_GNUC_CONST;
 340 static void gee_linked_list_node_free (GeeLinkedListNode* self);
 341 #define GEE_LINKED_LIST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_LINKED_LIST, GeeLinkedListPrivate))
 342 enum  {
 343         GEE_LINKED_LIST_DUMMY_PROPERTY,
 344         GEE_LINKED_LIST_G_TYPE,
 345         GEE_LINKED_LIST_G_DUP_FUNC,
 346         GEE_LINKED_LIST_G_DESTROY_FUNC,
 347         GEE_LINKED_LIST_EQUAL_FUNC,
 348         GEE_LINKED_LIST_SIZE,
 349         GEE_LINKED_LIST_CAPACITY,
 350         GEE_LINKED_LIST_REMAINING_CAPACITY,
 351         GEE_LINKED_LIST_IS_FULL
 352 };
 353 void gee_abstract_collection_clear (GeeAbstractCollection* self);
 354 GeeLinkedList* gee_linked_list_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GEqualFunc equal_func);
 355 GeeLinkedList* gee_linked_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GEqualFunc equal_func);
 356 GeeAbstractList* gee_abstract_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 357 GEqualFunc gee_functions_get_equal_func_for (GType t);
 358 static void gee_linked_list_set_equal_func (GeeLinkedList* self, GEqualFunc value);
 359 static GeeIterator* gee_linked_list_real_iterator (GeeAbstractCollection* base);
 360 static GeeLinkedListIterator* gee_linked_list_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list);
 361 static GeeLinkedListIterator* gee_linked_list_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list);
 362 static GType gee_linked_list_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 363 static GeeListIterator* gee_linked_list_real_list_iterator (GeeAbstractList* base);
 364 static gboolean gee_linked_list_real_contains (GeeAbstractCollection* base, gconstpointer item);
 365 gint gee_abstract_list_index_of (GeeAbstractList* self, gconstpointer item);
 366 static gboolean gee_linked_list_real_add (GeeAbstractCollection* base, gconstpointer item);
 367 static GeeLinkedListNode* gee_linked_list_node_new (gpointer data);
 368 static GeeLinkedListNode* gee_linked_list_node_new (gpointer data);
 369 static gboolean gee_linked_list_real_remove (GeeAbstractCollection* base, gconstpointer item);
 370 GEqualFunc gee_linked_list_get_equal_func (GeeLinkedList* self);
 371 static void _gee_linked_list_remove_node (GeeLinkedList* self, GeeLinkedListNode* _n);
 372 static void gee_linked_list_real_clear (GeeAbstractCollection* base);
 373 static gpointer gee_linked_list_real_get (GeeAbstractList* base, gint index);
 374 static GeeLinkedListNode* _gee_linked_list_get_node_at (GeeLinkedList* self, gint index);
 375 static void gee_linked_list_real_set (GeeAbstractList* base, gint index, gconstpointer item);
 376 static gint gee_linked_list_real_index_of (GeeAbstractList* base, gconstpointer item);
 377 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 378 gpointer gee_abstract_list_get (GeeAbstractList* self, gint index);
 379 static void gee_linked_list_real_insert (GeeAbstractList* base, gint index, gconstpointer item);
 380 gboolean gee_abstract_collection_add (GeeAbstractCollection* self, gconstpointer item);
 381 static gpointer gee_linked_list_real_remove_at (GeeAbstractList* base, gint index);
 382 static GeeList* gee_linked_list_real_slice (GeeAbstractList* base, gint start, gint stop);
 383 gboolean gee_collection_add (GeeCollection* self, gconstpointer item);
 384 static gpointer gee_linked_list_real_first (GeeAbstractList* base);
 385 static gpointer gee_linked_list_real_last (GeeAbstractList* base);
 386 static gboolean gee_linked_list_real_offer (GeeQueue* base, gconstpointer element);
 387 gboolean gee_deque_offer_tail (GeeDeque* self, gconstpointer element);
 388 static gpointer gee_linked_list_real_peek (GeeQueue* base);
 389 gpointer gee_deque_peek_head (GeeDeque* self);
 390 static gpointer gee_linked_list_real_poll (GeeQueue* base);
 391 gpointer gee_deque_poll_head (GeeDeque* self);
 392 static gint gee_linked_list_real_drain (GeeQueue* base, GeeCollection* recipient, gint amount);
 393 gint gee_deque_drain_head (GeeDeque* self, GeeCollection* recipient, gint amount);
 394 static gboolean gee_linked_list_real_offer_head (GeeDeque* base, gconstpointer element);
 395 void gee_abstract_list_insert (GeeAbstractList* self, gint index, gconstpointer item);
 396 static gpointer gee_linked_list_real_peek_head (GeeDeque* base);
 397 static gpointer gee_linked_list_real_poll_head (GeeDeque* base);
 398 gpointer gee_abstract_list_remove_at (GeeAbstractList* self, gint index);
 399 static gint gee_linked_list_real_drain_head (GeeDeque* base, GeeCollection* recipient, gint amount);
 400 static gboolean gee_linked_list_real_offer_tail (GeeDeque* base, gconstpointer element);
 401 static gpointer gee_linked_list_real_peek_tail (GeeDeque* base);
 402 static gpointer gee_linked_list_real_poll_tail (GeeDeque* base);
 403 static gint gee_linked_list_real_drain_tail (GeeDeque* base, GeeCollection* recipient, gint amount);
 404 #define GEE_QUEUE_UNBOUNDED_CAPACITY (-1)
 405 static void gee_linked_list_node_instance_init (GeeLinkedListNode * self);
 406 #define GEE_LINKED_LIST_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIteratorPrivate))
 407 enum  {
 408         GEE_LINKED_LIST_ITERATOR_DUMMY_PROPERTY,
 409         GEE_LINKED_LIST_ITERATOR_G_TYPE,
 410         GEE_LINKED_LIST_ITERATOR_G_DUP_FUNC,
 411         GEE_LINKED_LIST_ITERATOR_G_DESTROY_FUNC
 412 };
 413 static gboolean gee_linked_list_iterator_real_next (GeeIterator* base);
 414 static gboolean gee_linked_list_iterator_real_has_next (GeeIterator* base);
 415 static gboolean gee_linked_list_iterator_real_first (GeeIterator* base);
 416 static gpointer gee_linked_list_iterator_real_get (GeeIterator* base);
 417 static void gee_linked_list_iterator_real_remove (GeeIterator* base);
 418 static gboolean gee_linked_list_iterator_real_previous (GeeBidirIterator* base);
 419 static gboolean gee_linked_list_iterator_real_has_previous (GeeBidirIterator* base);
 420 static gboolean gee_linked_list_iterator_real_last (GeeBidirIterator* base);
 421 static void gee_linked_list_iterator_real_set (GeeListIterator* base, gconstpointer item);
 422 static void gee_linked_list_iterator_real_insert (GeeListIterator* base, gconstpointer item);
 423 static void gee_linked_list_iterator_real_add (GeeListIterator* base, gconstpointer item);
 424 static gint gee_linked_list_iterator_real_index (GeeListIterator* base);
 425 static void gee_linked_list_iterator_finalize (GObject* obj);
 426 static void _vala_gee_linked_list_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 427 static void _vala_gee_linked_list_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 428 static void gee_linked_list_finalize (GObject* obj);
 429 gint gee_queue_get_capacity (GeeQueue* self);
 430 gint gee_queue_get_remaining_capacity (GeeQueue* self);
 431 gboolean gee_queue_get_is_full (GeeQueue* self);
 432 static void _vala_gee_linked_list_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 433 static void _vala_gee_linked_list_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 434
 435
 436 /**
 437  * Constructs a new, empty linked list.
 438  *
 439  * If not provided, the function parameter is requested to the
 440  * {@link Functions} function factory methods.
 441  *
 442  * @param equal_func an optional element equality testing function
 443  */
 444 GeeLinkedList* gee_linked_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GEqualFunc equal_func) {
 445         GeeLinkedList * self = NULL;
 446         GEqualFunc _tmp0_;
 447         GEqualFunc _tmp2_;
 448         self = (GeeLinkedList*) gee_abstract_list_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
 449         self->priv->g_type = g_type;
 450         self->priv->g_dup_func = g_dup_func;
 451         self->priv->g_destroy_func = g_destroy_func;
 452         _tmp0_ = equal_func;
 453         if (_tmp0_ == NULL) {
 454                 GEqualFunc _tmp1_ = NULL;
 455                 _tmp1_ = gee_functions_get_equal_func_for (g_type);
 456                 equal_func = _tmp1_;
 457         }
 458         _tmp2_ = equal_func;
 459         gee_linked_list_set_equal_func (self, _tmp2_);
 460         return self;
 461 }
 462
 463
 464 GeeLinkedList* gee_linked_list_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GEqualFunc equal_func) {
 465         return gee_linked_list_construct (GEE_TYPE_LINKED_LIST, g_type, g_dup_func, g_destroy_func, equal_func);
 466 }
 467
 468
 469 /**
 470  * {@inheritDoc}
 471  */
 472 static GeeIterator* gee_linked_list_real_iterator (GeeAbstractCollection* base) {
 473         GeeLinkedList * self;
 474         GeeIterator* result = NULL;
 475         GeeLinkedListIterator* _tmp0_;
 476         self = (GeeLinkedList*) base;
 477         _tmp0_ = gee_linked_list_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
 478         result = (GeeIterator*) _tmp0_;
 479         return result;
 480 }
 481
 482
 483 /**
 484  * {@inheritDoc}
 485  */
 486 static GeeListIterator* gee_linked_list_real_list_iterator (GeeAbstractList* base) {
 487         GeeLinkedList * self;
 488         GeeListIterator* result = NULL;
 489         GeeLinkedListIterator* _tmp0_;
 490         self = (GeeLinkedList*) base;
 491         _tmp0_ = gee_linked_list_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
 492         result = (GeeListIterator*) _tmp0_;
 493         return result;
 494 }
 495
 496
 497 /**
 498  * {@inheritDoc}
 499  */
 500 static gboolean gee_linked_list_real_contains (GeeAbstractCollection* base, gconstpointer item) {
 501         GeeLinkedList * self;
 502         gboolean result = FALSE;
 503         gconstpointer _tmp0_;
 504         gint _tmp1_ = 0;
 505         self = (GeeLinkedList*) base;
 506         _tmp0_ = item;
 507         _tmp1_ = gee_abstract_list_index_of ((GeeAbstractList*) self, _tmp0_);
 508         result = _tmp1_ != (-1);
 509         return result;
 510 }
 511
 512
 513 /**
 514  * {@inheritDoc}
 515  */
 516 static gboolean gee_linked_list_real_add (GeeAbstractCollection* base, gconstpointer item) {
 517         GeeLinkedList * self;
 518         gboolean result = FALSE;
 519         gconstpointer _tmp0_;
 520         gpointer _tmp1_;
 521         GeeLinkedListNode* _tmp2_;
 522         GeeLinkedListNode* n;
 523         gboolean _tmp3_ = FALSE;
 524         GeeLinkedListNode* _tmp4_;
 525         gboolean _tmp6_;
 526         gint _tmp15_;
 527         self = (GeeLinkedList*) base;
 528         _tmp0_ = item;
 529         _tmp1_ = ((_tmp0_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
 530         _tmp2_ = gee_linked_list_node_new (_tmp1_);
 531         n = _tmp2_;
 532         _tmp4_ = self->priv->_head;
 533         if (_tmp4_ == NULL) {
 534                 GeeLinkedListNode* _tmp5_;
 535                 _tmp5_ = self->priv->_tail;
 536                 _tmp3_ = _tmp5_ == NULL;
 537         } else {
 538                 _tmp3_ = FALSE;
 539         }
 540         _tmp6_ = _tmp3_;
 541         if (_tmp6_) {
 542                 GeeLinkedListNode* _tmp7_;
 543                 GeeLinkedListNode* _tmp8_;
 544                 _tmp7_ = n;
 545                 self->priv->_tail = _tmp7_;
 546                 _tmp8_ = n;
 547                 n = NULL;
 548                 _gee_linked_list_node_free0 (self->priv->_head);
 549                 self->priv->_head = _tmp8_;
 550         } else {
 551                 GeeLinkedListNode* _tmp9_;
 552                 GeeLinkedListNode* _tmp10_;
 553                 GeeLinkedListNode* _tmp11_;
 554                 GeeLinkedListNode* _tmp12_;
 555                 GeeLinkedListNode* _tmp13_;
 556                 GeeLinkedListNode* _tmp14_;
 557                 _tmp9_ = n;
 558                 _tmp10_ = self->priv->_tail;
 559                 _tmp9_->prev = _tmp10_;
 560                 _tmp11_ = self->priv->_tail;
 561                 _tmp12_ = n;
 562                 n = NULL;
 563                 _gee_linked_list_node_free0 (_tmp11_->next);
 564                 _tmp11_->next = _tmp12_;
 565                 _tmp13_ = self->priv->_tail;
 566                 _tmp14_ = _tmp13_->next;
 567                 self->priv->_tail = _tmp14_;
 568         }
 569         _tmp15_ = self->priv->_size;
 570         self->priv->_size = _tmp15_ + 1;
 571         result = TRUE;
 572         _gee_linked_list_node_free0 (n);
 573         return result;
 574 }
 575
 576
 577 /**
 578  * {@inheritDoc}
 579  */
 580 static gboolean gee_linked_list_real_remove (GeeAbstractCollection* base, gconstpointer item) {
 581         GeeLinkedList * self;
 582         gboolean result = FALSE;
 583         self = (GeeLinkedList*) base;
 584         {
 585                 GeeLinkedListNode* _tmp0_;
 586                 GeeLinkedListNode* n;
 587                 _tmp0_ = self->priv->_head;
 588                 n = _tmp0_;
 589                 {
 590                         gboolean _tmp1_;
 591                         _tmp1_ = TRUE;
 592                         while (TRUE) {
 593                                 gboolean _tmp2_;
 594                                 GeeLinkedListNode* _tmp5_;
 595                                 GEqualFunc _tmp6_;
 596                                 GEqualFunc _tmp7_;
 597                                 gconstpointer _tmp8_;
 598                                 GeeLinkedListNode* _tmp9_;
 599                                 gconstpointer _tmp10_;
 600                                 gboolean _tmp11_ = FALSE;
 601                                 _tmp2_ = _tmp1_;
 602                                 if (!_tmp2_) {
 603                                         GeeLinkedListNode* _tmp3_;
 604                                         GeeLinkedListNode* _tmp4_;
 605                                         _tmp3_ = n;
 606                                         _tmp4_ = _tmp3_->next;
 607                                         n = _tmp4_;
 608                                 }
 609                                 _tmp1_ = FALSE;
 610                                 _tmp5_ = n;
 611                                 if (!(_tmp5_ != NULL)) {
 612                                         break;
 613                                 }
 614                                 _tmp6_ = gee_linked_list_get_equal_func (self);
 615                                 _tmp7_ = _tmp6_;
 616                                 _tmp8_ = item;
 617                                 _tmp9_ = n;
 618                                 _tmp10_ = _tmp9_->data;
 619                                 _tmp11_ = _tmp7_ (_tmp8_, _tmp10_);
 620                                 if (_tmp11_) {
 621                                         GeeLinkedListNode* _tmp12_;
 622                                         _tmp12_ = n;
 623                                         _gee_linked_list_remove_node (self, _tmp12_);
 624                                         result = TRUE;
 625                                         return result;
 626                                 }
 627                         }
 628                 }
 629         }
 630         result = FALSE;
 631         return result;
 632 }
 633
 634
 635 /**
 636  * {@inheritDoc}
 637  */
 638 static void gee_linked_list_real_clear (GeeAbstractCollection* base) {
 639         GeeLinkedList * self;
 640         gint _tmp2_;
 641         self = (GeeLinkedList*) base;
 642         while (TRUE) {
 643                 GeeLinkedListNode* _tmp0_;
 644                 GeeLinkedListNode* _tmp1_;
 645                 _tmp0_ = self->priv->_head;
 646                 if (!(_tmp0_ != NULL)) {
 647                         break;
 648                 }
 649                 _tmp1_ = self->priv->_head;
 650                 _gee_linked_list_remove_node (self, _tmp1_);
 651         }
 652         _tmp2_ = self->priv->_stamp;
 653         self->priv->_stamp = _tmp2_ + 1;
 654         _gee_linked_list_node_free0 (self->priv->_head);
 655         self->priv->_head = NULL;
 656         self->priv->_tail = NULL;
 657         self->priv->_size = 0;
 658 }
 659
 660
 661 /**
 662  * {@inheritDoc}
 663  */
 664 static gpointer gee_linked_list_real_get (GeeAbstractList* base, gint index) {
 665         GeeLinkedList * self;
 666         gpointer result = NULL;
 667         gint _tmp0_;
 668         gint _tmp1_;
 669         gint _tmp2_;
 670         gint _tmp3_;
 671         GeeLinkedListNode* _tmp4_ = NULL;
 672         GeeLinkedListNode* n;
 673         gconstpointer _tmp5_;
 674         gpointer _tmp6_;
 675         self = (GeeLinkedList*) base;
 676         _tmp0_ = index;
 677         _vala_assert (_tmp0_ >= 0, "index >= 0");
 678         _tmp1_ = index;
 679         _tmp2_ = self->priv->_size;
 680         _vala_assert (_tmp1_ < _tmp2_, "index < this._size");
 681         _tmp3_ = index;
 682         _tmp4_ = _gee_linked_list_get_node_at (self, _tmp3_);
 683         n = _tmp4_;
 684         _vala_assert (n != NULL, "n != null");
 685         _tmp5_ = n->data;
 686         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
 687         result = _tmp6_;
 688         return result;
 689 }
 690
 691
 692 /**
 693  * {@inheritDoc}
 694  */
 695 static void gee_linked_list_real_set (GeeAbstractList* base, gint index, gconstpointer item) {
 696         GeeLinkedList * self;
 697         gint _tmp0_;
 698         gint _tmp1_;
 699         gint _tmp2_;
 700         gint _tmp3_;
 701         GeeLinkedListNode* _tmp4_ = NULL;
 702         GeeLinkedListNode* n;
 703         gconstpointer _tmp5_;
 704         gpointer _tmp6_;
 705         self = (GeeLinkedList*) base;
 706         _tmp0_ = index;
 707         _vala_assert (_tmp0_ >= 0, "index >= 0");
 708         _tmp1_ = index;
 709         _tmp2_ = self->priv->_size;
 710         _vala_assert (_tmp1_ < _tmp2_, "index < this._size");
 711         _tmp3_ = index;
 712         _tmp4_ = _gee_linked_list_get_node_at (self, _tmp3_);
 713         n = _tmp4_;
 714         g_return_if_fail (n != NULL);
 715         _tmp5_ = item;
 716         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
 717         ((n->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (n->data = (self->priv->g_destroy_func (n->data), NULL));
 718         n->data = _tmp6_;
 719 }
 720
 721
 722 /**
 723  * {@inheritDoc}
 724  */
 725 static gpointer _g_object_ref0 (gpointer self) {
 726         return self ? g_object_ref (self) : NULL;
 727 }
 728
 729
 730 static gint gee_linked_list_real_index_of (GeeAbstractList* base, gconstpointer item) {
 731         GeeLinkedList * self;
 732         gint result = 0;
 733         gint _result_;
 734         gint idx;
 735         self = (GeeLinkedList*) base;
 736         _result_ = -1;
 737         idx = 0;
 738         {
 739                 GeeLinkedList* _tmp0_;
 740                 GeeLinkedList* _node_item_list;
 741                 GeeLinkedList* _tmp1_;
 742                 gint _tmp2_;
 743                 gint _tmp3_;
 744                 gint _node_item_size;
 745                 gint _node_item_index;
 746                 _tmp0_ = _g_object_ref0 (self);
 747                 _node_item_list = _tmp0_;
 748                 _tmp1_ = _node_item_list;
 749                 _tmp2_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp1_);
 750                 _tmp3_ = _tmp2_;
 751                 _node_item_size = _tmp3_;
 752                 _node_item_index = -1;
 753                 while (TRUE) {
 754                         gint _tmp4_;
 755                         gint _tmp5_;
 756                         gint _tmp6_;
 757                         GeeLinkedList* _tmp7_;
 758                         gint _tmp8_;
 759                         gpointer _tmp9_ = NULL;
 760                         gpointer node_item;
 761                         GEqualFunc _tmp10_;
 762                         GEqualFunc _tmp11_;
 763                         gconstpointer _tmp12_;
 764                         gconstpointer _tmp13_;
 765                         gboolean _tmp14_ = FALSE;
 766                         _tmp4_ = _node_item_index;
 767                         _node_item_index = _tmp4_ + 1;
 768                         _tmp5_ = _node_item_index;
 769                         _tmp6_ = _node_item_size;
 770                         if (!(_tmp5_ < _tmp6_)) {
 771                                 break;
 772                         }
 773                         _tmp7_ = _node_item_list;
 774                         _tmp8_ = _node_item_index;
 775                         _tmp9_ = gee_abstract_list_get ((GeeAbstractList*) _tmp7_, _tmp8_);
 776                         node_item = _tmp9_;
 777                         _tmp10_ = gee_linked_list_get_equal_func (self);
 778                         _tmp11_ = _tmp10_;
 779                         _tmp12_ = item;
 780                         _tmp13_ = node_item;
 781                         _tmp14_ = _tmp11_ (_tmp12_, _tmp13_);
 782                         if (_tmp14_) {
 783                                 gint _tmp15_;
 784                                 _tmp15_ = idx;
 785                                 _result_ = _tmp15_;
 786                                 ((node_item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (node_item = (self->priv->g_destroy_func (node_item), NULL));
 787                                 break;
 788                         } else {
 789                                 gint _tmp16_;
 790                                 _tmp16_ = idx;
 791                                 idx = _tmp16_ + 1;
 792                         }
 793                         ((node_item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (node_item = (self->priv->g_destroy_func (node_item), NULL));
 794                 }
 795                 _g_object_unref0 (_node_item_list);
 796         }
 797         result = _result_;
 798         return result;
 799 }
 800
 801
 802 /**
 803  * {@inheritDoc}
 804  */
 805 static void gee_linked_list_real_insert (GeeAbstractList* base, gint index, gconstpointer item) {
 806         GeeLinkedList * self;
 807         gint _tmp0_;
 808         gint _tmp1_;
 809         gint _tmp2_;
 810         gint _tmp3_;
 811         gint _tmp4_;
 812         self = (GeeLinkedList*) base;
 813         _tmp0_ = index;
 814         _vala_assert (_tmp0_ >= 0, "index >= 0");
 815         _tmp1_ = index;
 816         _tmp2_ = self->priv->_size;
 817         _vala_assert (_tmp1_ <= _tmp2_, "index <= this._size");
 818         _tmp3_ = index;
 819         _tmp4_ = self->priv->_size;
 820         if (_tmp3_ == _tmp4_) {
 821                 gconstpointer _tmp5_;
 822                 _tmp5_ = item;
 823                 gee_abstract_collection_add ((GeeAbstractCollection*) self, _tmp5_);
 824         } else {
 825                 gconstpointer _tmp6_;
 826                 gpointer _tmp7_;
 827                 GeeLinkedListNode* _tmp8_;
 828                 GeeLinkedListNode* n;
 829                 gint _tmp9_;
 830                 gint _tmp34_;
 831                 _tmp6_ = item;
 832                 _tmp7_ = ((_tmp6_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp6_) : ((gpointer) _tmp6_);
 833                 _tmp8_ = gee_linked_list_node_new (_tmp7_);
 834                 n = _tmp8_;
 835                 _tmp9_ = index;
 836                 if (_tmp9_ == 0) {
 837                         GeeLinkedListNode* _tmp10_;
 838                         GeeLinkedListNode* _tmp11_;
 839                         GeeLinkedListNode* _tmp12_;
 840                         GeeLinkedListNode* _tmp13_;
 841                         GeeLinkedListNode* _tmp14_;
 842                         GeeLinkedListNode* _tmp15_;
 843                         _tmp10_ = n;
 844                         _tmp11_ = self->priv->_head;
 845                         self->priv->_head = NULL;
 846                         _gee_linked_list_node_free0 (_tmp10_->next);
 847                         _tmp10_->next = _tmp11_;
 848                         _tmp12_ = n;
 849                         _tmp13_ = _tmp12_->next;
 850                         _tmp14_ = n;
 851                         _tmp13_->prev = _tmp14_;
 852                         _tmp15_ = n;
 853                         n = NULL;
 854                         _gee_linked_list_node_free0 (self->priv->_head);
 855                         self->priv->_head = _tmp15_;
 856                 } else {
 857                         GeeLinkedListNode* _tmp16_;
 858                         GeeLinkedListNode* prev;
 859                         GeeLinkedListNode* _tmp24_;
 860                         GeeLinkedListNode* _tmp25_;
 861                         GeeLinkedListNode* _tmp26_;
 862                         GeeLinkedListNode* _tmp27_;
 863                         GeeLinkedListNode* _tmp28_;
 864                         GeeLinkedListNode* _tmp29_;
 865                         GeeLinkedListNode* _tmp30_;
 866                         GeeLinkedListNode* _tmp31_;
 867                         GeeLinkedListNode* _tmp32_;
 868                         GeeLinkedListNode* _tmp33_;
 869                         _tmp16_ = self->priv->_head;
 870                         prev = _tmp16_;
 871                         {
 872                                 gint i;
 873                                 i = 0;
 874                                 {
 875                                         gboolean _tmp17_;
 876                                         _tmp17_ = TRUE;
 877                                         while (TRUE) {
 878                                                 gboolean _tmp18_;
 879                                                 gint _tmp20_;
 880                                                 gint _tmp21_;
 881                                                 GeeLinkedListNode* _tmp22_;
 882                                                 GeeLinkedListNode* _tmp23_;
 883                                                 _tmp18_ = _tmp17_;
 884                                                 if (!_tmp18_) {
 885                                                         gint _tmp19_;
 886                                                         _tmp19_ = i;
 887                                                         i = _tmp19_ + 1;
 888                                                 }
 889                                                 _tmp17_ = FALSE;
 890                                                 _tmp20_ = i;
 891                                                 _tmp21_ = index;
 892                                                 if (!(_tmp20_ < (_tmp21_ - 1))) {
 893                                                         break;
 894                                                 }
 895                                                 _tmp22_ = prev;
 896                                                 _tmp23_ = _tmp22_->next;
 897                                                 prev = _tmp23_;
 898                                         }
 899                                 }
 900                         }
 901                         _tmp24_ = n;
 902                         _tmp25_ = prev;
 903                         _tmp24_->prev = _tmp25_;
 904                         _tmp26_ = n;
 905                         _tmp27_ = prev;
 906                         _tmp28_ = _tmp27_->next;
 907                         _tmp27_->next = NULL;
 908                         _gee_linked_list_node_free0 (_tmp26_->next);
 909                         _tmp26_->next = _tmp28_;
 910                         _tmp29_ = n;
 911                         _tmp30_ = _tmp29_->next;
 912                         _tmp31_ = n;
 913                         _tmp30_->prev = _tmp31_;
 914                         _tmp32_ = prev;
 915                         _tmp33_ = n;
 916                         n = NULL;
 917                         _gee_linked_list_node_free0 (_tmp32_->next);
 918                         _tmp32_->next = _tmp33_;
 919                 }
 920                 _tmp34_ = self->priv->_size;
 921                 self->priv->_size = _tmp34_ + 1;
 922                 _gee_linked_list_node_free0 (n);
 923         }
 924 }
 925
 926
 927 /**
 928  * {@inheritDoc}
 929  */
 930 static gpointer gee_linked_list_real_remove_at (GeeAbstractList* base, gint index) {
 931         GeeLinkedList * self;
 932         gpointer result = NULL;
 933         gint _tmp0_;
 934         gint _tmp1_;
 935         gint _tmp2_;
 936         gint _tmp3_;
 937         GeeLinkedListNode* _tmp4_ = NULL;
 938         GeeLinkedListNode* n;
 939         gconstpointer _tmp5_;
 940         gpointer _tmp6_;
 941         gpointer element;
 942         self = (GeeLinkedList*) base;
 943         _tmp0_ = index;
 944         _vala_assert (_tmp0_ >= 0, "index >= 0");
 945         _tmp1_ = index;
 946         _tmp2_ = self->priv->_size;
 947         _vala_assert (_tmp1_ < _tmp2_, "index < this._size");
 948         _tmp3_ = index;
 949         _tmp4_ = _gee_linked_list_get_node_at (self, _tmp3_);
 950         n = _tmp4_;
 951         _vala_assert (n != NULL, "n != null");
 952         _tmp5_ = n->data;
 953         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
 954         element = _tmp6_;
 955         _gee_linked_list_remove_node (self, n);
 956         result = element;
 957         return result;
 958 }
 959
 960
 961 /**
 962  * {@inheritDoc}
 963  */
 964 static GeeList* gee_linked_list_real_slice (GeeAbstractList* base, gint start, gint stop) {
 965         GeeLinkedList * self;
 966         GeeList* result = NULL;
 967         gint _tmp0_;
 968         gint _tmp1_;
 969         gint _tmp2_;
 970         gint _tmp3_;
 971         gint _tmp4_;
 972         GEqualFunc _tmp5_;
 973         GEqualFunc _tmp6_;
 974         GeeLinkedList* _tmp7_;
 975         GeeList* slice;
 976         gint _tmp8_;
 977         GeeLinkedListNode* _tmp9_ = NULL;
 978         GeeLinkedListNode* n;
 979         self = (GeeLinkedList*) base;
 980         _tmp0_ = start;
 981         _tmp1_ = stop;
 982         g_return_val_if_fail (_tmp0_ <= _tmp1_, NULL);
 983         _tmp2_ = start;
 984         g_return_val_if_fail (_tmp2_ >= 0, NULL);
 985         _tmp3_ = stop;
 986         _tmp4_ = self->priv->_size;
 987         g_return_val_if_fail (_tmp3_ <= _tmp4_, NULL);
 988         _tmp5_ = gee_linked_list_get_equal_func (self);
 989         _tmp6_ = _tmp5_;
 990         _tmp7_ = gee_linked_list_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp6_);
 991         slice = (GeeList*) _tmp7_;
 992         _tmp8_ = start;
 993         _tmp9_ = _gee_linked_list_get_node_at (self, _tmp8_);
 994         n = _tmp9_;
 995         {
 996                 gint _tmp10_;
 997                 gint i;
 998                 _tmp10_ = start;
 999                 i = _tmp10_;
1000                 {
1001                         gboolean _tmp11_;
1002                         _tmp11_ = TRUE;
1003                         while (TRUE) {
1004                                 gboolean _tmp12_;
1005                                 gint _tmp14_;
1006                                 gint _tmp15_;
1007                                 GeeList* _tmp16_;
1008                                 GeeLinkedListNode* _tmp17_;
1009                                 gconstpointer _tmp18_;
1010                                 GeeLinkedListNode* _tmp19_;
1011                                 GeeLinkedListNode* _tmp20_;
1012                                 _tmp12_ = _tmp11_;
1013                                 if (!_tmp12_) {
1014                                         gint _tmp13_;
1015                                         _tmp13_ = i;
1016                                         i = _tmp13_ + 1;
1017                                 }
1018                                 _tmp11_ = FALSE;
1019                                 _tmp14_ = i;
1020                                 _tmp15_ = stop;
1021                                 if (!(_tmp14_ < _tmp15_)) {
1022                                         break;
1023                                 }
1024                                 _tmp16_ = slice;
1025                                 _tmp17_ = n;
1026                                 _tmp18_ = _tmp17_->data;
1027                                 gee_collection_add ((GeeCollection*) _tmp16_, _tmp18_);
1028                                 _tmp19_ = n;
1029                                 _tmp20_ = _tmp19_->next;
1030                                 n = _tmp20_;
1031                         }
1032                 }
1033         }
1034         result = slice;
1035         return result;
1036 }
1037
1038
1039 /**
1040  * {@inheritDoc}
1041  */
1042 static gpointer gee_linked_list_real_first (GeeAbstractList* base) {
1043         GeeLinkedList * self;
1044         gpointer result = NULL;
1045         gint _tmp0_;
1046         GeeLinkedListNode* _tmp1_;
1047         gconstpointer _tmp2_;
1048         gpointer _tmp3_;
1049         self = (GeeLinkedList*) base;
1050         _tmp0_ = self->priv->_size;
1051         _vala_assert (_tmp0_ > 0, "_size > 0");
1052         _tmp1_ = self->priv->_head;
1053         _tmp2_ = _tmp1_->data;
1054         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
1055         result = _tmp3_;
1056         return result;
1057 }
1058
1059
1060 /**
1061  * {@inheritDoc}
1062  */
1063 static gpointer gee_linked_list_real_last (GeeAbstractList* base) {
1064         GeeLinkedList * self;
1065         gpointer result = NULL;
1066         gint _tmp0_;
1067         GeeLinkedListNode* _tmp1_;
1068         gconstpointer _tmp2_;
1069         gpointer _tmp3_;
1070         self = (GeeLinkedList*) base;
1071         _tmp0_ = self->priv->_size;
1072         _vala_assert (_tmp0_ > 0, "_size > 0");
1073         _tmp1_ = self->priv->_tail;
1074         _tmp2_ = _tmp1_->data;
1075         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
1076         result = _tmp3_;
1077         return result;
1078 }
1079
1080
1081 /**
1082  * {@inheritDoc}
1083  */
1084 static gboolean gee_linked_list_real_offer (GeeQueue* base, gconstpointer element) {
1085         GeeLinkedList * self;
1086         gboolean result = FALSE;
1087         gconstpointer _tmp0_;
1088         gboolean _tmp1_ = FALSE;
1089         self = (GeeLinkedList*) base;
1090         _tmp0_ = element;
1091         _tmp1_ = gee_deque_offer_tail ((GeeDeque*) self, _tmp0_);
1092         result = _tmp1_;
1093         return result;
1094 }
1095
1096
1097 /**
1098  * {@inheritDoc}
1099  */
1100 static gpointer gee_linked_list_real_peek (GeeQueue* base) {
1101         GeeLinkedList * self;
1102         gpointer result = NULL;
1103         gpointer _tmp0_ = NULL;
1104         self = (GeeLinkedList*) base;
1105         _tmp0_ = gee_deque_peek_head ((GeeDeque*) self);
1106         result = _tmp0_;
1107         return result;
1108 }
1109
1110
1111 /**
1112  * {@inheritDoc}
1113  */
1114 static gpointer gee_linked_list_real_poll (GeeQueue* base) {
1115         GeeLinkedList * self;
1116         gpointer result = NULL;
1117         gpointer _tmp0_ = NULL;
1118         self = (GeeLinkedList*) base;
1119         _tmp0_ = gee_deque_poll_head ((GeeDeque*) self);
1120         result = _tmp0_;
1121         return result;
1122 }
1123
1124
1125 /**
1126  * {@inheritDoc}
1127  */
1128 static gint gee_linked_list_real_drain (GeeQueue* base, GeeCollection* recipient, gint amount) {
1129         GeeLinkedList * self;
1130         gint result = 0;
1131         GeeCollection* _tmp0_;
1132         gint _tmp1_;
1133         gint _tmp2_ = 0;
1134         self = (GeeLinkedList*) base;
1135         g_return_val_if_fail (recipient != NULL, 0);
1136         _tmp0_ = recipient;
1137         _tmp1_ = amount;
1138         _tmp2_ = gee_deque_drain_head ((GeeDeque*) self, _tmp0_, _tmp1_);
1139         result = _tmp2_;
1140         return result;
1141 }
1142
1143
1144 /**
1145  * {@inheritDoc}
1146  */
1147 static gboolean gee_linked_list_real_offer_head (GeeDeque* base, gconstpointer element) {
1148         GeeLinkedList * self;
1149         gboolean result = FALSE;
1150         gconstpointer _tmp0_;
1151         self = (GeeLinkedList*) base;
1152         _tmp0_ = element;
1153         gee_abstract_list_insert ((GeeAbstractList*) self, 0, _tmp0_);
1154         result = TRUE;
1155         return result;
1156 }
1157
1158
1159 /**
1160  * {@inheritDoc}
1161  */
1162 static gpointer gee_linked_list_real_peek_head (GeeDeque* base) {
1163         GeeLinkedList * self;
1164         gpointer result = NULL;
1165         gint _tmp0_;
1166         gpointer _tmp1_ = NULL;
1167         self = (GeeLinkedList*) base;
1168         _tmp0_ = self->priv->_size;
1169         if (_tmp0_ == 0) {
1170                 result = NULL;
1171                 return result;
1172         }
1173         _tmp1_ = gee_abstract_list_get ((GeeAbstractList*) self, 0);
1174         result = _tmp1_;
1175         return result;
1176 }
1177
1178
1179 /**
1180  * {@inheritDoc}
1181  */
1182 static gpointer gee_linked_list_real_poll_head (GeeDeque* base) {
1183         GeeLinkedList * self;
1184         gpointer result = NULL;
1185         gint _tmp0_;
1186         gpointer _tmp1_ = NULL;
1187         self = (GeeLinkedList*) base;
1188         _tmp0_ = self->priv->_size;
1189         if (_tmp0_ == 0) {
1190                 result = NULL;
1191                 return result;
1192         }
1193         _tmp1_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, 0);
1194         result = _tmp1_;
1195         return result;
1196 }
1197
1198
1199 /**
1200  * {@inheritDoc}
1201  */
1202 static gint gee_linked_list_real_drain_head (GeeDeque* base, GeeCollection* recipient, gint amount) {
1203         GeeLinkedList * self;
1204         gint result = 0;
1205         gint _tmp0_;
1206         gint _tmp11_;
1207         self = (GeeLinkedList*) base;
1208         g_return_val_if_fail (recipient != NULL, 0);
1209         _tmp0_ = amount;
1210         if (_tmp0_ == (-1)) {
1211                 gint _tmp1_;
1212                 _tmp1_ = self->priv->_size;
1213                 amount = _tmp1_;
1214         }
1215         {
1216                 gint i;
1217                 i = 0;
1218                 {
1219                         gboolean _tmp2_;
1220                         _tmp2_ = TRUE;
1221                         while (TRUE) {
1222                                 gboolean _tmp3_;
1223                                 gint _tmp5_;
1224                                 gint _tmp6_;
1225                                 gint _tmp7_;
1226                                 GeeCollection* _tmp8_;
1227                                 gpointer _tmp9_ = NULL;
1228                                 gpointer _tmp10_;
1229                                 _tmp3_ = _tmp2_;
1230                                 if (!_tmp3_) {
1231                                         gint _tmp4_;
1232                                         _tmp4_ = i;
1233                                         i = _tmp4_ + 1;
1234                                 }
1235                                 _tmp2_ = FALSE;
1236                                 _tmp5_ = i;
1237                                 _tmp6_ = amount;
1238                                 if (!(_tmp5_ < _tmp6_)) {
1239                                         break;
1240                                 }
1241                                 _tmp7_ = self->priv->_size;
1242                                 if (_tmp7_ == 0) {
1243                                         result = i;
1244                                         return result;
1245                                 }
1246                                 _tmp8_ = recipient;
1247                                 _tmp9_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, 0);
1248                                 _tmp10_ = _tmp9_;
1249                                 gee_collection_add (_tmp8_, _tmp10_);
1250                                 ((_tmp10_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp10_ = (self->priv->g_destroy_func (_tmp10_), NULL));
1251                         }
1252                 }
1253         }
1254         _tmp11_ = amount;
1255         result = _tmp11_;
1256         return result;
1257 }
1258
1259
1260 /**
1261  * {@inheritDoc}
1262  */
1263 static gboolean gee_linked_list_real_offer_tail (GeeDeque* base, gconstpointer element) {
1264         GeeLinkedList * self;
1265         gboolean result = FALSE;
1266         gconstpointer _tmp0_;
1267         gboolean _tmp1_ = FALSE;
1268         self = (GeeLinkedList*) base;
1269         _tmp0_ = element;
1270         _tmp1_ = gee_abstract_collection_add ((GeeAbstractCollection*) self, _tmp0_);
1271         result = _tmp1_;
1272         return result;
1273 }
1274
1275
1276 /**
1277  * {@inheritDoc}
1278  */
1279 static gpointer gee_linked_list_real_peek_tail (GeeDeque* base) {
1280         GeeLinkedList * self;
1281         gpointer result = NULL;
1282         gint _tmp0_;
1283         gint _tmp1_;
1284         gpointer _tmp2_ = NULL;
1285         self = (GeeLinkedList*) base;
1286         _tmp0_ = self->priv->_size;
1287         if (_tmp0_ == 0) {
1288                 result = NULL;
1289                 return result;
1290         }
1291         _tmp1_ = self->priv->_size;
1292         _tmp2_ = gee_abstract_list_get ((GeeAbstractList*) self, _tmp1_ - 1);
1293         result = _tmp2_;
1294         return result;
1295 }
1296
1297
1298 /**
1299  * {@inheritDoc}
1300  */
1301 static gpointer gee_linked_list_real_poll_tail (GeeDeque* base) {
1302         GeeLinkedList * self;
1303         gpointer result = NULL;
1304         gint _tmp0_;
1305         gint _tmp1_;
1306         gpointer _tmp2_ = NULL;
1307         self = (GeeLinkedList*) base;
1308         _tmp0_ = self->priv->_size;
1309         if (_tmp0_ == 0) {
1310                 result = NULL;
1311                 return result;
1312         }
1313         _tmp1_ = self->priv->_size;
1314         _tmp2_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, _tmp1_ - 1);
1315         result = _tmp2_;
1316         return result;
1317 }
1318
1319
1320 /**
1321  * {@inheritDoc}
1322  */
1323 static gint gee_linked_list_real_drain_tail (GeeDeque* base, GeeCollection* recipient, gint amount) {
1324         GeeLinkedList * self;
1325         gint result = 0;
1326         gint _tmp0_;
1327         gint _tmp12_;
1328         self = (GeeLinkedList*) base;
1329         g_return_val_if_fail (recipient != NULL, 0);
1330         _tmp0_ = amount;
1331         if (_tmp0_ == (-1)) {
1332                 gint _tmp1_;
1333                 _tmp1_ = self->priv->_size;
1334                 amount = _tmp1_;
1335         }
1336         {
1337                 gint i;
1338                 i = 0;
1339                 {
1340                         gboolean _tmp2_;
1341                         _tmp2_ = TRUE;
1342                         while (TRUE) {
1343                                 gboolean _tmp3_;
1344                                 gint _tmp5_;
1345                                 gint _tmp6_;
1346                                 gint _tmp7_;
1347                                 GeeCollection* _tmp8_;
1348                                 gint _tmp9_;
1349                                 gpointer _tmp10_ = NULL;
1350                                 gpointer _tmp11_;
1351                                 _tmp3_ = _tmp2_;
1352                                 if (!_tmp3_) {
1353                                         gint _tmp4_;
1354                                         _tmp4_ = i;
1355                                         i = _tmp4_ + 1;
1356                                 }
1357                                 _tmp2_ = FALSE;
1358                                 _tmp5_ = i;
1359                                 _tmp6_ = amount;
1360                                 if (!(_tmp5_ < _tmp6_)) {
1361                                         break;
1362                                 }
1363                                 _tmp7_ = self->priv->_size;
1364                                 if (_tmp7_ == 0) {
1365                                         result = i;
1366                                         return result;
1367                                 }
1368                                 _tmp8_ = recipient;
1369                                 _tmp9_ = self->priv->_size;
1370                                 _tmp10_ = gee_abstract_list_remove_at ((GeeAbstractList*) self, _tmp9_ - 1);
1371                                 _tmp11_ = _tmp10_;
1372                                 gee_collection_add (_tmp8_, _tmp11_);
1373                                 ((_tmp11_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp11_ = (self->priv->g_destroy_func (_tmp11_), NULL));
1374                         }
1375                 }
1376         }
1377         _tmp12_ = amount;
1378         result = _tmp12_;
1379         return result;
1380 }
1381
1382
1383 static GeeLinkedListNode* _gee_linked_list_get_node_at (GeeLinkedList* self, gint index) {
1384         GeeLinkedListNode* result = NULL;
1385         GeeLinkedListNode* n;
1386         gint _tmp0_;
1387         GeeLinkedListNode* _tmp24_;
1388         g_return_val_if_fail (self != NULL, NULL);
1389         n = NULL;
1390         _tmp0_ = index;
1391         if (_tmp0_ == 0) {
1392                 GeeLinkedListNode* _tmp1_;
1393                 _tmp1_ = self->priv->_head;
1394                 n = _tmp1_;
1395         } else {
1396                 gint _tmp2_;
1397                 gint _tmp3_;
1398                 _tmp2_ = index;
1399                 _tmp3_ = self->priv->_size;
1400                 if (_tmp2_ == (_tmp3_ - 1)) {
1401                         GeeLinkedListNode* _tmp4_;
1402                         _tmp4_ = self->priv->_tail;
1403                         n = _tmp4_;
1404                 } else {
1405                         gint _tmp5_;
1406                         gint _tmp6_;
1407                         _tmp5_ = index;
1408                         _tmp6_ = self->priv->_size;
1409                         if (_tmp5_ <= (_tmp6_ / 2)) {
1410                                 GeeLinkedListNode* _tmp7_;
1411                                 _tmp7_ = self->priv->_head;
1412                                 n = _tmp7_;
1413                                 {
1414                                         gint i;
1415                                         i = 0;
1416                                         {
1417                                                 gboolean _tmp8_;
1418                                                 _tmp8_ = TRUE;
1419                                                 while (TRUE) {
1420                                                         gboolean _tmp9_;
1421                                                         gint _tmp11_;
1422                                                         gint _tmp12_;
1423                                                         GeeLinkedListNode* _tmp13_;
1424                                                         GeeLinkedListNode* _tmp14_;
1425                                                         _tmp9_ = _tmp8_;
1426                                                         if (!_tmp9_) {
1427                                                                 gint _tmp10_;
1428                                                                 _tmp10_ = i;
1429                                                                 i = _tmp10_ + 1;
1430                                                         }
1431                                                         _tmp8_ = FALSE;
1432                                                         _tmp11_ = index;
1433                                                         _tmp12_ = i;
1434                                                         if (!(_tmp11_ != _tmp12_)) {
1435                                                                 break;
1436                                                         }
1437                                                         _tmp13_ = n;
1438                                                         _tmp14_ = _tmp13_->next;
1439                                                         n = _tmp14_;
1440                                                 }
1441                                         }
1442                                 }
1443                         } else {
1444                                 GeeLinkedListNode* _tmp15_;
1445                                 _tmp15_ = self->priv->_tail;
1446                                 n = _tmp15_;
1447                                 {
1448                                         gint _tmp16_;
1449                                         gint i;
1450                                         _tmp16_ = self->priv->_size;
1451                                         i = _tmp16_ - 1;
1452                                         {
1453                                                 gboolean _tmp17_;
1454                                                 _tmp17_ = TRUE;
1455                                                 while (TRUE) {
1456                                                         gboolean _tmp18_;
1457                                                         gint _tmp20_;
1458                                                         gint _tmp21_;
1459                                                         GeeLinkedListNode* _tmp22_;
1460                                                         GeeLinkedListNode* _tmp23_;
1461                                                         _tmp18_ = _tmp17_;
1462                                                         if (!_tmp18_) {
1463                                                                 gint _tmp19_;
1464                                                                 _tmp19_ = i;
1465                                                                 i = _tmp19_ - 1;
1466                                                         }
1467                                                         _tmp17_ = FALSE;
1468                                                         _tmp20_ = index;
1469                                                         _tmp21_ = i;
1470                                                         if (!(_tmp20_ != _tmp21_)) {
1471                                                                 break;
1472                                                         }
1473                                                         _tmp22_ = n;
1474                                                         _tmp23_ = _tmp22_->prev;
1475                                                         n = _tmp23_;
1476                                                 }
1477                                         }
1478                                 }
1479                         }
1480                 }
1481         }
1482         _tmp24_ = n;
1483         result = _tmp24_;
1484         return result;
1485 }
1486
1487
1488 static void _gee_linked_list_remove_node (GeeLinkedList* self, GeeLinkedListNode* _n) {
1489         GeeLinkedListNode* n = NULL;
1490         GeeLinkedListNode* next = NULL;
1491         GeeLinkedListNode* _tmp0_;
1492         GeeLinkedListNode* _tmp1_;
1493         GeeLinkedListNode* _tmp14_;
1494         GeeLinkedListNode* _tmp15_;
1495         GeeLinkedListNode* _tmp21_;
1496         GeeLinkedListNode* _tmp22_;
1497         GeeLinkedListNode* _tmp23_;
1498         gint _tmp24_;
1499         gint _tmp25_;
1500         g_return_if_fail (self != NULL);
1501         g_return_if_fail (_n != NULL);
1502         _tmp0_ = _n;
1503         _tmp1_ = self->priv->_head;
1504         if (_tmp0_ == _tmp1_) {
1505                 GeeLinkedListNode* _tmp2_;
1506                 GeeLinkedListNode* _tmp3_;
1507                 GeeLinkedListNode* _tmp4_;
1508                 GeeLinkedListNode* _tmp5_;
1509                 _tmp2_ = self->priv->_head;
1510                 self->priv->_head = NULL;
1511                 _gee_linked_list_node_free0 (n);
1512                 n = _tmp2_;
1513                 _tmp3_ = n;
1514                 _tmp4_ = _tmp3_->next;
1515                 _tmp3_->next = NULL;
1516                 _gee_linked_list_node_free0 (self->priv->_head);
1517                 self->priv->_head = _tmp4_;
1518                 _tmp5_ = self->priv->_head;
1519                 next = _tmp5_;
1520         } else {
1521                 GeeLinkedListNode* _tmp6_;
1522                 GeeLinkedListNode* _tmp7_;
1523                 GeeLinkedListNode* _tmp8_;
1524                 GeeLinkedListNode* _tmp9_;
1525                 GeeLinkedListNode* _tmp10_;
1526                 GeeLinkedListNode* _tmp11_;
1527                 GeeLinkedListNode* _tmp12_;
1528                 GeeLinkedListNode* _tmp13_;
1529                 _tmp6_ = _n;
1530                 _tmp7_ = _tmp6_->prev;
1531                 _tmp8_ = _tmp7_->next;
1532                 _tmp7_->next = NULL;
1533                 _gee_linked_list_node_free0 (n);
1534                 n = _tmp8_;
1535                 _tmp9_ = n;
1536                 _tmp10_ = _tmp9_->prev;
1537                 _tmp11_ = n;
1538                 _tmp12_ = _tmp11_->next;
1539                 _tmp11_->next = NULL;
1540                 _gee_linked_list_node_free0 (_tmp10_->next);
1541                 _tmp10_->next = _tmp12_;
1542                 _tmp13_ = _tmp10_->next;
1543                 next = _tmp13_;
1544         }
1545         _tmp14_ = n;
1546         _tmp15_ = self->priv->_tail;
1547         if (_tmp14_ == _tmp15_) {
1548                 GeeLinkedListNode* _tmp16_;
1549                 GeeLinkedListNode* _tmp17_;
1550                 _tmp16_ = n;
1551                 _tmp17_ = _tmp16_->prev;
1552                 self->priv->_tail = _tmp17_;
1553         } else {
1554                 GeeLinkedListNode* _tmp18_;
1555                 GeeLinkedListNode* _tmp19_;
1556                 GeeLinkedListNode* _tmp20_;
1557                 _tmp18_ = next;
1558                 _tmp19_ = n;
1559                 _tmp20_ = _tmp19_->prev;
1560                 _tmp18_->prev = _tmp20_;
1561         }
1562         _tmp21_ = n;
1563         _tmp21_->prev = NULL;
1564         _tmp22_ = n;
1565         _gee_linked_list_node_free0 (_tmp22_->next);
1566         _tmp22_->next = NULL;
1567         _tmp23_ = n;
1568         ((_tmp23_->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp23_->data = (self->priv->g_destroy_func (_tmp23_->data), NULL));
1569         _tmp23_->data = NULL;
1570         _tmp24_ = self->priv->_stamp;
1571         self->priv->_stamp = _tmp24_ + 1;
1572         _tmp25_ = self->priv->_size;
1573         self->priv->_size = _tmp25_ - 1;
1574         _gee_linked_list_node_free0 (n);
1575 }
1576
1577
1578 GEqualFunc gee_linked_list_get_equal_func (GeeLinkedList* self) {
1579         GEqualFunc result;
1580         GEqualFunc _tmp0_;
1581         g_return_val_if_fail (self != NULL, NULL);
1582         _tmp0_ = self->priv->_equal_func;
1583         result = _tmp0_;
1584         return result;
1585 }
1586
1587
1588 static void gee_linked_list_set_equal_func (GeeLinkedList* self, GEqualFunc value) {
1589         GEqualFunc _tmp0_;
1590         g_return_if_fail (self != NULL);
1591         _tmp0_ = value;
1592         self->priv->_equal_func = _tmp0_;
1593         g_object_notify ((GObject *) self, "equal-func");
1594 }
1595
1596
1597 static gint gee_linked_list_real_get_size (GeeAbstractCollection* base) {
1598         gint result;
1599         GeeLinkedList* self;
1600         gint _tmp0_;
1601         self = (GeeLinkedList*) base;
1602         _tmp0_ = self->priv->_size;
1603         result = _tmp0_;
1604         return result;
1605 }
1606
1607
1608 static gint gee_linked_list_real_get_capacity (GeeQueue* base) {
1609         gint result;
1610         GeeLinkedList* self;
1611         self = (GeeLinkedList*) base;
1612         result = GEE_QUEUE_UNBOUNDED_CAPACITY;
1613         return result;
1614 }
1615
1616
1617 static gint gee_linked_list_real_get_remaining_capacity (GeeQueue* base) {
1618         gint result;
1619         GeeLinkedList* self;
1620         self = (GeeLinkedList*) base;
1621         result = GEE_QUEUE_UNBOUNDED_CAPACITY;
1622         return result;
1623 }
1624
1625
1626 static gboolean gee_linked_list_real_get_is_full (GeeQueue* base) {
1627         gboolean result;
1628         GeeLinkedList* self;
1629         self = (GeeLinkedList*) base;
1630         result = FALSE;
1631         return result;
1632 }
1633
1634
1635 static GeeLinkedListNode* gee_linked_list_node_new (gpointer data) {
1636         GeeLinkedListNode* self;
1637         gconstpointer _tmp0_;
1638         self = g_slice_new0 (GeeLinkedListNode);
1639         gee_linked_list_node_instance_init (self);
1640         _tmp0_ = data;
1641         self->data = _tmp0_;
1642         return self;
1643 }
1644
1645
1646 static void gee_linked_list_node_instance_init (GeeLinkedListNode * self) {
1647         self->prev = NULL;
1648         self->next = NULL;
1649 }
1650
1651
1652 static void gee_linked_list_node_free (GeeLinkedListNode* self) {
1653         _gee_linked_list_node_free0 (self->next);
1654         g_slice_free (GeeLinkedListNode, self);
1655 }
1656
1657
1658 static GeeLinkedListIterator* gee_linked_list_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list) {
1659         GeeLinkedListIterator * self = NULL;
1660         GeeLinkedList* _tmp0_;
1661         GeeLinkedList* _tmp1_;
1662         GeeLinkedList* _tmp2_;
1663         gint _tmp3_;
1664         g_return_val_if_fail (list != NULL, NULL);
1665         self = (GeeLinkedListIterator*) g_object_new (object_type, NULL);
1666         self->priv->g_type = g_type;
1667         self->priv->g_dup_func = g_dup_func;
1668         self->priv->g_destroy_func = g_destroy_func;
1669         _tmp0_ = list;
1670         _tmp1_ = _g_object_ref0 (_tmp0_);
1671         _g_object_unref0 (self->priv->_list);
1672         self->priv->_list = _tmp1_;
1673         self->priv->position = NULL;
1674         self->priv->_index = -1;
1675         _tmp2_ = list;
1676         _tmp3_ = _tmp2_->priv->_stamp;
1677         self->priv->_stamp = _tmp3_;
1678         return self;
1679 }
1680
1681
1682 static GeeLinkedListIterator* gee_linked_list_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeLinkedList* list) {
1683         return gee_linked_list_iterator_construct (GEE_LINKED_LIST_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, list);
1684 }
1685
1686
1687 static gboolean gee_linked_list_iterator_real_next (GeeIterator* base) {
1688         GeeLinkedListIterator * self;
1689         gboolean result = FALSE;
1690         gint _tmp0_;
1691         GeeLinkedList* _tmp1_;
1692         gint _tmp2_;
1693         gboolean _tmp3_ = FALSE;
1694         gboolean _tmp4_;
1695         gboolean _tmp6_;
1696         self = (GeeLinkedListIterator*) base;
1697         _tmp0_ = self->priv->_stamp;
1698         _tmp1_ = self->priv->_list;
1699         _tmp2_ = _tmp1_->priv->_stamp;
1700         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1701         _tmp4_ = self->priv->removed;
1702         if (_tmp4_) {
1703                 GeeLinkedListNode* _tmp5_;
1704                 _tmp5_ = self->priv->position;
1705                 _tmp3_ = _tmp5_ != NULL;
1706         } else {
1707                 _tmp3_ = FALSE;
1708         }
1709         _tmp6_ = _tmp3_;
1710         if (_tmp6_) {
1711                 self->priv->removed = FALSE;
1712                 result = TRUE;
1713                 return result;
1714         } else {
1715                 gboolean _tmp7_ = FALSE;
1716                 gboolean _tmp8_;
1717                 gboolean _tmp11_;
1718                 _tmp8_ = self->priv->started;
1719                 if (!_tmp8_) {
1720                         GeeLinkedList* _tmp9_;
1721                         GeeLinkedListNode* _tmp10_;
1722                         _tmp9_ = self->priv->_list;
1723                         _tmp10_ = _tmp9_->priv->_head;
1724                         _tmp7_ = _tmp10_ != NULL;
1725                 } else {
1726                         _tmp7_ = FALSE;
1727                 }
1728                 _tmp11_ = _tmp7_;
1729                 if (_tmp11_) {
1730                         GeeLinkedList* _tmp12_;
1731                         GeeLinkedListNode* _tmp13_;
1732                         gint _tmp14_;
1733                         self->priv->started = TRUE;
1734                         _tmp12_ = self->priv->_list;
1735                         _tmp13_ = _tmp12_->priv->_head;
1736                         self->priv->position = _tmp13_;
1737                         _tmp14_ = self->priv->_index;
1738                         self->priv->_index = _tmp14_ + 1;
1739                         result = TRUE;
1740                         return result;
1741                 } else {
1742                         gboolean _tmp15_ = FALSE;
1743                         GeeLinkedListNode* _tmp16_;
1744                         gboolean _tmp19_;
1745                         _tmp16_ = self->priv->position;
1746                         if (_tmp16_ != NULL) {
1747                                 GeeLinkedListNode* _tmp17_;
1748                                 GeeLinkedListNode* _tmp18_;
1749                                 _tmp17_ = self->priv->position;
1750                                 _tmp18_ = _tmp17_->next;
1751                                 _tmp15_ = _tmp18_ != NULL;
1752                         } else {
1753                                 _tmp15_ = FALSE;
1754                         }
1755                         _tmp19_ = _tmp15_;
1756                         if (_tmp19_) {
1757                                 GeeLinkedListNode* _tmp20_;
1758                                 GeeLinkedListNode* _tmp21_;
1759                                 gint _tmp22_;
1760                                 _tmp20_ = self->priv->position;
1761                                 _tmp21_ = _tmp20_->next;
1762                                 self->priv->position = _tmp21_;
1763                                 _tmp22_ = self->priv->_index;
1764                                 self->priv->_index = _tmp22_ + 1;
1765                                 result = TRUE;
1766                                 return result;
1767                         }
1768                 }
1769         }
1770         result = FALSE;
1771         return result;
1772 }
1773
1774
1775 static gboolean gee_linked_list_iterator_real_has_next (GeeIterator* base) {
1776         GeeLinkedListIterator * self;
1777         gboolean result = FALSE;
1778         gint _tmp0_;
1779         GeeLinkedList* _tmp1_;
1780         gint _tmp2_;
1781         gboolean _tmp3_;
1782         self = (GeeLinkedListIterator*) base;
1783         _tmp0_ = self->priv->_stamp;
1784         _tmp1_ = self->priv->_list;
1785         _tmp2_ = _tmp1_->priv->_stamp;
1786         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1787         _tmp3_ = self->priv->removed;
1788         if (_tmp3_) {
1789                 GeeLinkedListNode* _tmp4_;
1790                 _tmp4_ = self->priv->position;
1791                 result = _tmp4_ != NULL;
1792                 return result;
1793         } else {
1794                 gboolean _tmp5_;
1795                 _tmp5_ = self->priv->started;
1796                 if (!_tmp5_) {
1797                         GeeLinkedList* _tmp6_;
1798                         GeeLinkedListNode* _tmp7_;
1799                         _tmp6_ = self->priv->_list;
1800                         _tmp7_ = _tmp6_->priv->_head;
1801                         result = _tmp7_ != NULL;
1802                         return result;
1803                 } else {
1804                         GeeLinkedListNode* _tmp8_;
1805                         _tmp8_ = self->priv->position;
1806                         if (_tmp8_ != NULL) {
1807                                 GeeLinkedListNode* _tmp9_;
1808                                 GeeLinkedListNode* _tmp10_;
1809                                 _tmp9_ = self->priv->position;
1810                                 _tmp10_ = _tmp9_->next;
1811                                 result = _tmp10_ != NULL;
1812                                 return result;
1813                         }
1814                 }
1815         }
1816         result = FALSE;
1817         return result;
1818 }
1819
1820
1821 static gboolean gee_linked_list_iterator_real_first (GeeIterator* base) {
1822         GeeLinkedListIterator * self;
1823         gboolean result = FALSE;
1824         gint _tmp0_;
1825         GeeLinkedList* _tmp1_;
1826         gint _tmp2_;
1827         GeeLinkedList* _tmp3_;
1828         gint _tmp4_;
1829         gint _tmp5_;
1830         GeeLinkedList* _tmp6_;
1831         GeeLinkedListNode* _tmp7_;
1832         GeeLinkedListNode* _tmp8_;
1833         self = (GeeLinkedListIterator*) base;
1834         _tmp0_ = self->priv->_stamp;
1835         _tmp1_ = self->priv->_list;
1836         _tmp2_ = _tmp1_->priv->_stamp;
1837         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1838         _tmp3_ = self->priv->_list;
1839         _tmp4_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp3_);
1840         _tmp5_ = _tmp4_;
1841         if (_tmp5_ == 0) {
1842                 result = FALSE;
1843                 return result;
1844         }
1845         _tmp6_ = self->priv->_list;
1846         _tmp7_ = _tmp6_->priv->_head;
1847         self->priv->position = _tmp7_;
1848         self->priv->started = TRUE;
1849         self->priv->_index = 0;
1850         self->priv->removed = FALSE;
1851         _tmp8_ = self->priv->position;
1852         result = _tmp8_ != NULL;
1853         return result;
1854 }
1855
1856
1857 static gpointer gee_linked_list_iterator_real_get (GeeIterator* base) {
1858         GeeLinkedListIterator * self;
1859         gpointer result = NULL;
1860         gint _tmp0_;
1861         GeeLinkedList* _tmp1_;
1862         gint _tmp2_;
1863         GeeLinkedListNode* _tmp3_;
1864         GeeLinkedListNode* _tmp4_;
1865         gconstpointer _tmp5_;
1866         gpointer _tmp6_;
1867         self = (GeeLinkedListIterator*) base;
1868         _tmp0_ = self->priv->_stamp;
1869         _tmp1_ = self->priv->_list;
1870         _tmp2_ = _tmp1_->priv->_stamp;
1871         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1872         _tmp3_ = self->priv->position;
1873         _vala_assert (_tmp3_ != NULL, "this.position != null");
1874         _tmp4_ = self->priv->position;
1875         _tmp5_ = _tmp4_->data;
1876         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
1877         result = _tmp6_;
1878         return result;
1879 }
1880
1881
1882 static void gee_linked_list_iterator_real_remove (GeeIterator* base) {
1883         GeeLinkedListIterator * self;
1884         gint _tmp0_;
1885         GeeLinkedList* _tmp1_;
1886         gint _tmp2_;
1887         GeeLinkedListNode* _tmp3_;
1888         GeeLinkedListNode* _tmp4_;
1889         GeeLinkedListNode* _tmp5_;
1890         GeeLinkedListNode* new_position;
1891         GeeLinkedListNode* _tmp6_;
1892         GeeLinkedList* _tmp7_;
1893         GeeLinkedListNode* _tmp8_;
1894         GeeLinkedListNode* _tmp9_;
1895         GeeLinkedList* _tmp10_;
1896         gint _tmp11_;
1897         self = (GeeLinkedListIterator*) base;
1898         _tmp0_ = self->priv->_stamp;
1899         _tmp1_ = self->priv->_list;
1900         _tmp2_ = _tmp1_->priv->_stamp;
1901         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1902         _tmp3_ = self->priv->position;
1903         _vala_assert (_tmp3_ != NULL, "this.position != null");
1904         _tmp4_ = self->priv->position;
1905         _tmp5_ = _tmp4_->next;
1906         new_position = _tmp5_;
1907         _tmp6_ = new_position;
1908         if (_tmp6_ == NULL) {
1909                 self->priv->started = FALSE;
1910         }
1911         _tmp7_ = self->priv->_list;
1912         _tmp8_ = self->priv->position;
1913         _gee_linked_list_remove_node (_tmp7_, _tmp8_);
1914         _tmp9_ = new_position;
1915         self->priv->position = _tmp9_;
1916         self->priv->removed = TRUE;
1917         _tmp10_ = self->priv->_list;
1918         _tmp11_ = _tmp10_->priv->_stamp;
1919         self->priv->_stamp = _tmp11_;
1920 }
1921
1922
1923 static gboolean gee_linked_list_iterator_real_previous (GeeBidirIterator* base) {
1924         GeeLinkedListIterator * self;
1925         gboolean result = FALSE;
1926         gint _tmp0_;
1927         GeeLinkedList* _tmp1_;
1928         gint _tmp2_;
1929         gboolean _tmp3_;
1930         self = (GeeLinkedListIterator*) base;
1931         _tmp0_ = self->priv->_stamp;
1932         _tmp1_ = self->priv->_list;
1933         _tmp2_ = _tmp1_->priv->_stamp;
1934         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1935         _tmp3_ = self->priv->started;
1936         if (!_tmp3_) {
1937                 self->priv->position = NULL;
1938                 result = FALSE;
1939                 return result;
1940         } else {
1941                 gboolean _tmp4_ = FALSE;
1942                 GeeLinkedListNode* _tmp5_;
1943                 gboolean _tmp8_;
1944                 _tmp5_ = self->priv->position;
1945                 if (_tmp5_ != NULL) {
1946                         GeeLinkedListNode* _tmp6_;
1947                         GeeLinkedListNode* _tmp7_;
1948                         _tmp6_ = self->priv->position;
1949                         _tmp7_ = _tmp6_->prev;
1950                         _tmp4_ = _tmp7_ != NULL;
1951                 } else {
1952                         _tmp4_ = FALSE;
1953                 }
1954                 _tmp8_ = _tmp4_;
1955                 if (_tmp8_) {
1956                         GeeLinkedListNode* _tmp9_;
1957                         GeeLinkedListNode* _tmp10_;
1958                         gint _tmp11_;
1959                         _tmp9_ = self->priv->position;
1960                         _tmp10_ = _tmp9_->prev;
1961                         self->priv->position = _tmp10_;
1962                         _tmp11_ = self->priv->_index;
1963                         self->priv->_index = _tmp11_ - 1;
1964                         result = TRUE;
1965                         return result;
1966                 }
1967         }
1968         result = FALSE;
1969         return result;
1970 }
1971
1972
1973 static gboolean gee_linked_list_iterator_real_has_previous (GeeBidirIterator* base) {
1974         GeeLinkedListIterator * self;
1975         gboolean result = FALSE;
1976         gint _tmp0_;
1977         GeeLinkedList* _tmp1_;
1978         gint _tmp2_;
1979         gboolean _tmp3_;
1980         self = (GeeLinkedListIterator*) base;
1981         _tmp0_ = self->priv->_stamp;
1982         _tmp1_ = self->priv->_list;
1983         _tmp2_ = _tmp1_->priv->_stamp;
1984         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
1985         _tmp3_ = self->priv->started;
1986         if (!_tmp3_) {
1987                 result = FALSE;
1988                 return result;
1989         } else {
1990                 GeeLinkedListNode* _tmp4_;
1991                 _tmp4_ = self->priv->position;
1992                 if (_tmp4_ != NULL) {
1993                         GeeLinkedListNode* _tmp5_;
1994                         GeeLinkedListNode* _tmp6_;
1995                         _tmp5_ = self->priv->position;
1996                         _tmp6_ = _tmp5_->prev;
1997                         result = _tmp6_ != NULL;
1998                         return result;
1999                 }
2000         }
2001         result = FALSE;
2002         return result;
2003 }
2004
2005
2006 static gboolean gee_linked_list_iterator_real_last (GeeBidirIterator* base) {
2007         GeeLinkedListIterator * self;
2008         gboolean result = FALSE;
2009         gint _tmp0_;
2010         GeeLinkedList* _tmp1_;
2011         gint _tmp2_;
2012         GeeLinkedList* _tmp3_;
2013         gint _tmp4_;
2014         gint _tmp5_;
2015         GeeLinkedList* _tmp6_;
2016         GeeLinkedListNode* _tmp7_;
2017         GeeLinkedList* _tmp8_;
2018         gint _tmp9_;
2019         GeeLinkedListNode* _tmp10_;
2020         self = (GeeLinkedListIterator*) base;
2021         _tmp0_ = self->priv->_stamp;
2022         _tmp1_ = self->priv->_list;
2023         _tmp2_ = _tmp1_->priv->_stamp;
2024         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2025         _tmp3_ = self->priv->_list;
2026         _tmp4_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp3_);
2027         _tmp5_ = _tmp4_;
2028         if (_tmp5_ == 0) {
2029                 result = FALSE;
2030                 return result;
2031         }
2032         _tmp6_ = self->priv->_list;
2033         _tmp7_ = _tmp6_->priv->_tail;
2034         self->priv->position = _tmp7_;
2035         self->priv->started = TRUE;
2036         _tmp8_ = self->priv->_list;
2037         _tmp9_ = _tmp8_->priv->_size;
2038         self->priv->_index = _tmp9_ - 1;
2039         _tmp10_ = self->priv->position;
2040         result = _tmp10_ != NULL;
2041         return result;
2042 }
2043
2044
2045 static void gee_linked_list_iterator_real_set (GeeListIterator* base, gconstpointer item) {
2046         GeeLinkedListIterator * self;
2047         gint _tmp0_;
2048         GeeLinkedList* _tmp1_;
2049         gint _tmp2_;
2050         GeeLinkedListNode* _tmp3_;
2051         GeeLinkedListNode* _tmp4_;
2052         gconstpointer _tmp5_;
2053         gpointer _tmp6_;
2054         self = (GeeLinkedListIterator*) base;
2055         _tmp0_ = self->priv->_stamp;
2056         _tmp1_ = self->priv->_list;
2057         _tmp2_ = _tmp1_->priv->_stamp;
2058         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2059         _tmp3_ = self->priv->position;
2060         _vala_assert (_tmp3_ != NULL, "this.position != null");
2061         _tmp4_ = self->priv->position;
2062         _tmp5_ = item;
2063         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
2064         ((_tmp4_->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp4_->data = (self->priv->g_destroy_func (_tmp4_->data), NULL));
2065         _tmp4_->data = _tmp6_;
2066 }
2067
2068
2069 static void gee_linked_list_iterator_real_insert (GeeListIterator* base, gconstpointer item) {
2070         GeeLinkedListIterator * self;
2071         gint _tmp0_;
2072         GeeLinkedList* _tmp1_;
2073         gint _tmp2_;
2074         GeeLinkedListNode* _tmp3_;
2075         gconstpointer _tmp4_;
2076         gpointer _tmp5_;
2077         GeeLinkedListNode* _tmp6_;
2078         GeeLinkedListNode* n;
2079         GeeLinkedListNode* _tmp7_;
2080         GeeLinkedListNode* _tmp8_;
2081         GeeLinkedList* _tmp31_;
2082         gint _tmp32_;
2083         gint _tmp33_;
2084         GeeLinkedList* _tmp34_;
2085         gint _tmp35_;
2086         self = (GeeLinkedListIterator*) base;
2087         _tmp0_ = self->priv->_stamp;
2088         _tmp1_ = self->priv->_list;
2089         _tmp2_ = _tmp1_->priv->_stamp;
2090         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2091         _tmp3_ = self->priv->position;
2092         _vala_assert (_tmp3_ != NULL, "this.position != null");
2093         _tmp4_ = item;
2094         _tmp5_ = ((_tmp4_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp4_) : ((gpointer) _tmp4_);
2095         _tmp6_ = gee_linked_list_node_new (_tmp5_);
2096         n = _tmp6_;
2097         _tmp7_ = self->priv->position;
2098         _tmp8_ = _tmp7_->prev;
2099         if (_tmp8_ != NULL) {
2100                 GeeLinkedListNode* _tmp9_;
2101                 GeeLinkedListNode* _tmp10_;
2102                 GeeLinkedListNode* _tmp11_;
2103                 GeeLinkedListNode* position;
2104                 GeeLinkedListNode* _tmp12_;
2105                 GeeLinkedListNode* _tmp13_;
2106                 GeeLinkedListNode* _tmp14_;
2107                 GeeLinkedListNode* _tmp15_;
2108                 GeeLinkedListNode* _tmp16_;
2109                 GeeLinkedListNode* _tmp17_;
2110                 GeeLinkedListNode* _tmp18_;
2111                 GeeLinkedListNode* _tmp19_;
2112                 GeeLinkedListNode* _n;
2113                 GeeLinkedListNode* _tmp20_;
2114                 GeeLinkedListNode* _tmp21_;
2115                 GeeLinkedListNode* _tmp22_;
2116                 _tmp9_ = self->priv->position;
2117                 _tmp10_ = _tmp9_->prev;
2118                 _tmp11_ = _tmp10_->next;
2119                 _tmp10_->next = NULL;
2120                 position = _tmp11_;
2121                 _tmp12_ = n;
2122                 _tmp13_ = position;
2123                 _tmp14_ = _tmp13_->prev;
2124                 _tmp12_->prev = _tmp14_;
2125                 _tmp15_ = position;
2126                 _tmp16_ = n;
2127                 _tmp15_->prev = _tmp16_;
2128                 _tmp17_ = n;
2129                 _tmp18_ = position;
2130                 position = NULL;
2131                 _gee_linked_list_node_free0 (_tmp17_->next);
2132                 _tmp17_->next = _tmp18_;
2133                 _tmp19_ = n;
2134                 _n = _tmp19_;
2135                 _tmp20_ = _n;
2136                 _tmp21_ = _tmp20_->prev;
2137                 _tmp22_ = n;
2138                 n = NULL;
2139                 _gee_linked_list_node_free0 (_tmp21_->next);
2140                 _tmp21_->next = _tmp22_;
2141                 _gee_linked_list_node_free0 (position);
2142         } else {
2143                 GeeLinkedList* _tmp23_;
2144                 GeeLinkedListNode* _tmp24_;
2145                 GeeLinkedListNode* position;
2146                 GeeLinkedListNode* _tmp25_;
2147                 GeeLinkedListNode* _tmp26_;
2148                 GeeLinkedListNode* _tmp27_;
2149                 GeeLinkedListNode* _tmp28_;
2150                 GeeLinkedList* _tmp29_;
2151                 GeeLinkedListNode* _tmp30_;
2152                 _tmp23_ = self->priv->_list;
2153                 _tmp24_ = _tmp23_->priv->_head;
2154                 _tmp23_->priv->_head = NULL;
2155                 position = _tmp24_;
2156                 _tmp25_ = position;
2157                 _tmp26_ = n;
2158                 _tmp25_->prev = _tmp26_;
2159                 _tmp27_ = n;
2160                 _tmp28_ = position;
2161                 position = NULL;
2162                 _gee_linked_list_node_free0 (_tmp27_->next);
2163                 _tmp27_->next = _tmp28_;
2164                 _tmp29_ = self->priv->_list;
2165                 _tmp30_ = n;
2166                 n = NULL;
2167                 _gee_linked_list_node_free0 (_tmp29_->priv->_head);
2168                 _tmp29_->priv->_head = _tmp30_;
2169                 _gee_linked_list_node_free0 (position);
2170         }
2171         _tmp31_ = self->priv->_list;
2172         _tmp32_ = _tmp31_->priv->_size;
2173         _tmp31_->priv->_size = _tmp32_ + 1;
2174         _tmp33_ = self->priv->_index;
2175         self->priv->_index = _tmp33_ + 1;
2176         _tmp34_ = self->priv->_list;
2177         _tmp35_ = _tmp34_->priv->_stamp;
2178         self->priv->_stamp = _tmp35_;
2179         _gee_linked_list_node_free0 (n);
2180 }
2181
2182
2183 static void gee_linked_list_iterator_real_add (GeeListIterator* base, gconstpointer item) {
2184         GeeLinkedListIterator * self;
2185         gint _tmp0_;
2186         GeeLinkedList* _tmp1_;
2187         gint _tmp2_;
2188         GeeLinkedListNode* _tmp3_;
2189         gconstpointer _tmp4_;
2190         gpointer _tmp5_;
2191         GeeLinkedListNode* _tmp6_;
2192         GeeLinkedListNode* n;
2193         GeeLinkedListNode* _tmp7_;
2194         GeeLinkedListNode* _tmp8_;
2195         GeeLinkedListNode* _tmp17_;
2196         GeeLinkedListNode* _tmp18_;
2197         GeeLinkedListNode* _tmp19_;
2198         GeeLinkedListNode* _tmp20_;
2199         GeeLinkedListNode* _tmp21_;
2200         GeeLinkedListNode* _tmp22_;
2201         GeeLinkedListNode* _tmp23_;
2202         GeeLinkedList* _tmp24_;
2203         gint _tmp25_;
2204         gint _tmp26_;
2205         GeeLinkedList* _tmp27_;
2206         gint _tmp28_;
2207         self = (GeeLinkedListIterator*) base;
2208         _tmp0_ = self->priv->_stamp;
2209         _tmp1_ = self->priv->_list;
2210         _tmp2_ = _tmp1_->priv->_stamp;
2211         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2212         _tmp3_ = self->priv->position;
2213         _vala_assert (_tmp3_ != NULL, "this.position != null");
2214         _tmp4_ = item;
2215         _tmp5_ = ((_tmp4_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp4_) : ((gpointer) _tmp4_);
2216         _tmp6_ = gee_linked_list_node_new (_tmp5_);
2217         n = _tmp6_;
2218         _tmp7_ = self->priv->position;
2219         _tmp8_ = _tmp7_->next;
2220         if (_tmp8_ != NULL) {
2221                 GeeLinkedListNode* _tmp9_;
2222                 GeeLinkedListNode* _tmp10_;
2223                 GeeLinkedListNode* _tmp11_;
2224                 GeeLinkedListNode* _tmp12_;
2225                 GeeLinkedListNode* _tmp13_;
2226                 GeeLinkedListNode* _tmp14_;
2227                 _tmp9_ = self->priv->position;
2228                 _tmp10_ = _tmp9_->next;
2229                 _tmp11_ = n;
2230                 _tmp10_->prev = _tmp11_;
2231                 _tmp12_ = n;
2232                 _tmp13_ = self->priv->position;
2233                 _tmp14_ = _tmp13_->next;
2234                 _tmp13_->next = NULL;
2235                 _gee_linked_list_node_free0 (_tmp12_->next);
2236                 _tmp12_->next = _tmp14_;
2237         } else {
2238                 GeeLinkedList* _tmp15_;
2239                 GeeLinkedListNode* _tmp16_;
2240                 _tmp15_ = self->priv->_list;
2241                 _tmp16_ = n;
2242                 _tmp15_->priv->_tail = _tmp16_;
2243         }
2244         _tmp17_ = self->priv->position;
2245         _tmp18_ = n;
2246         n = NULL;
2247         _gee_linked_list_node_free0 (_tmp17_->next);
2248         _tmp17_->next = _tmp18_;
2249         _tmp19_ = self->priv->position;
2250         _tmp20_ = _tmp19_->next;
2251         _tmp21_ = self->priv->position;
2252         _tmp20_->prev = _tmp21_;
2253         _tmp22_ = self->priv->position;
2254         _tmp23_ = _tmp22_->next;
2255         self->priv->position = _tmp23_;
2256         _tmp24_ = self->priv->_list;
2257         _tmp25_ = _tmp24_->priv->_size;
2258         _tmp24_->priv->_size = _tmp25_ + 1;
2259         _tmp26_ = self->priv->_index;
2260         self->priv->_index = _tmp26_ + 1;
2261         _tmp27_ = self->priv->_list;
2262         _tmp28_ = _tmp27_->priv->_stamp;
2263         self->priv->_stamp = _tmp28_;
2264         _gee_linked_list_node_free0 (n);
2265 }
2266
2267
2268 static gint gee_linked_list_iterator_real_index (GeeListIterator* base) {
2269         GeeLinkedListIterator * self;
2270         gint result = 0;
2271         gint _tmp0_;
2272         GeeLinkedList* _tmp1_;
2273         gint _tmp2_;
2274         GeeLinkedListNode* _tmp3_;
2275         gint _tmp4_;
2276         self = (GeeLinkedListIterator*) base;
2277         _tmp0_ = self->priv->_stamp;
2278         _tmp1_ = self->priv->_list;
2279         _tmp2_ = _tmp1_->priv->_stamp;
2280         _vala_assert (_tmp0_ == _tmp2_, "this._stamp == this._list._stamp");
2281         _tmp3_ = self->priv->position;
2282         _vala_assert (_tmp3_ != NULL, "this.position != null");
2283         _tmp4_ = self->priv->_index;
2284         result = _tmp4_;
2285         return result;
2286 }
2287
2288
2289 static void gee_linked_list_iterator_class_init (GeeLinkedListIteratorClass * klass) {
2290         gee_linked_list_iterator_parent_class = g_type_class_peek_parent (klass);
2291         g_type_class_add_private (klass, sizeof (GeeLinkedListIteratorPrivate));
2292         G_OBJECT_CLASS (klass)->get_property = _vala_gee_linked_list_iterator_get_property;
2293         G_OBJECT_CLASS (klass)->set_property = _vala_gee_linked_list_iterator_set_property;
2294         G_OBJECT_CLASS (klass)->finalize = gee_linked_list_iterator_finalize;
2295         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));
2296         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));
2297         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));
2298 }
2299
2300
2301 static void gee_linked_list_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
2302         gee_linked_list_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
2303         iface->next = (gboolean (*)(GeeIterator*)) gee_linked_list_iterator_real_next;
2304         iface->has_next = (gboolean (*)(GeeIterator*)) gee_linked_list_iterator_real_has_next;
2305         iface->first = (gboolean (*)(GeeIterator*)) gee_linked_list_iterator_real_first;
2306         iface->get = (gpointer (*)(GeeIterator*)) gee_linked_list_iterator_real_get;
2307         iface->remove = (void (*)(GeeIterator*)) gee_linked_list_iterator_real_remove;
2308 }
2309
2310
2311 static void gee_linked_list_iterator_gee_bidir_iterator_interface_init (GeeBidirIteratorIface * iface) {
2312         gee_linked_list_iterator_gee_bidir_iterator_parent_iface = g_type_interface_peek_parent (iface);
2313         iface->previous = (gboolean (*)(GeeBidirIterator*)) gee_linked_list_iterator_real_previous;
2314         iface->has_previous = (gboolean (*)(GeeBidirIterator*)) gee_linked_list_iterator_real_has_previous;
2315         iface->last = (gboolean (*)(GeeBidirIterator*)) gee_linked_list_iterator_real_last;
2316 }
2317
2318
2319 static void gee_linked_list_iterator_gee_list_iterator_interface_init (GeeListIteratorIface * iface) {
2320         gee_linked_list_iterator_gee_list_iterator_parent_iface = g_type_interface_peek_parent (iface);
2321         iface->set = (void (*)(GeeListIterator*, gconstpointer)) gee_linked_list_iterator_real_set;
2322         iface->insert = (void (*)(GeeListIterator*, gconstpointer)) gee_linked_list_iterator_real_insert;
2323         iface->add = (void (*)(GeeListIterator*, gconstpointer)) gee_linked_list_iterator_real_add;
2324         iface->index = (gint (*)(GeeListIterator*)) gee_linked_list_iterator_real_index;
2325 }
2326
2327
2328 static void gee_linked_list_iterator_instance_init (GeeLinkedListIterator * self) {
2329         self->priv = GEE_LINKED_LIST_ITERATOR_GET_PRIVATE (self);
2330         self->priv->started = FALSE;
2331         self->priv->removed = FALSE;
2332 }
2333
2334
2335 static void gee_linked_list_iterator_finalize (GObject* obj) {
2336         GeeLinkedListIterator * self;
2337         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator);
2338         _g_object_unref0 (self->priv->_list);
2339         G_OBJECT_CLASS (gee_linked_list_iterator_parent_class)->finalize (obj);
2340 }
2341
2342
2343 static GType gee_linked_list_iterator_get_type (void) {
2344         static volatile gsize gee_linked_list_iterator_type_id__volatile = 0;
2345         if (g_once_init_enter (&gee_linked_list_iterator_type_id__volatile)) {
2346                 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 };
2347                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2348                 static const GInterfaceInfo gee_bidir_iterator_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_bidir_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2349                 static const GInterfaceInfo gee_list_iterator_info = { (GInterfaceInitFunc) gee_linked_list_iterator_gee_list_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2350                 GType gee_linked_list_iterator_type_id;
2351                 gee_linked_list_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeLinkedListIterator", &g_define_type_info, 0);
2352                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
2353                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_BIDIR_ITERATOR, &gee_bidir_iterator_info);
2354                 g_type_add_interface_static (gee_linked_list_iterator_type_id, GEE_TYPE_LIST_ITERATOR, &gee_list_iterator_info);
2355                 g_once_init_leave (&gee_linked_list_iterator_type_id__volatile, gee_linked_list_iterator_type_id);
2356         }
2357         return gee_linked_list_iterator_type_id__volatile;
2358 }
2359
2360
2361 static void _vala_gee_linked_list_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2362         GeeLinkedListIterator * self;
2363         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator);
2364         switch (property_id) {
2365                 default:
2366                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2367                 break;
2368         }
2369 }
2370
2371
2372 static void _vala_gee_linked_list_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2373         GeeLinkedListIterator * self;
2374         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_LINKED_LIST_TYPE_ITERATOR, GeeLinkedListIterator);
2375         switch (property_id) {
2376                 case GEE_LINKED_LIST_ITERATOR_G_TYPE:
2377                 self->priv->g_type = g_value_get_gtype (value);
2378                 break;
2379                 case GEE_LINKED_LIST_ITERATOR_G_DUP_FUNC:
2380                 self->priv->g_dup_func = g_value_get_pointer (value);
2381                 break;
2382                 case GEE_LINKED_LIST_ITERATOR_G_DESTROY_FUNC:
2383                 self->priv->g_destroy_func = g_value_get_pointer (value);
2384                 break;
2385                 default:
2386                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2387                 break;
2388         }
2389 }
2390
2391
2392 static void gee_linked_list_class_init (GeeLinkedListClass * klass) {
2393         gee_linked_list_parent_class = g_type_class_peek_parent (klass);
2394         g_type_class_add_private (klass, sizeof (GeeLinkedListPrivate));
2395         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_linked_list_real_iterator;
2396         GEE_ABSTRACT_LIST_CLASS (klass)->list_iterator = gee_linked_list_real_list_iterator;
2397         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_linked_list_real_contains;
2398         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_linked_list_real_add;
2399         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_linked_list_real_remove;
2400         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_linked_list_real_clear;
2401         GEE_ABSTRACT_LIST_CLASS (klass)->get = gee_linked_list_real_get;
2402         GEE_ABSTRACT_LIST_CLASS (klass)->set = gee_linked_list_real_set;
2403         GEE_ABSTRACT_LIST_CLASS (klass)->index_of = gee_linked_list_real_index_of;
2404         GEE_ABSTRACT_LIST_CLASS (klass)->insert = gee_linked_list_real_insert;
2405         GEE_ABSTRACT_LIST_CLASS (klass)->remove_at = gee_linked_list_real_remove_at;
2406         GEE_ABSTRACT_LIST_CLASS (klass)->slice = gee_linked_list_real_slice;
2407         GEE_ABSTRACT_LIST_CLASS (klass)->first = gee_linked_list_real_first;
2408         GEE_ABSTRACT_LIST_CLASS (klass)->last = gee_linked_list_real_last;
2409         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_linked_list_real_get_size;
2410         G_OBJECT_CLASS (klass)->get_property = _vala_gee_linked_list_get_property;
2411         G_OBJECT_CLASS (klass)->set_property = _vala_gee_linked_list_set_property;
2412         G_OBJECT_CLASS (klass)->finalize = gee_linked_list_finalize;
2413         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));
2414         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));
2415         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));
2416         /**
2417          * The elements' equality testing function.
2418          */
2419         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_LINKED_LIST_EQUAL_FUNC, g_param_spec_pointer ("equal-func", "equal-func", "equal-func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2420         /**
2421          * {@inheritDoc}
2422          */
2423         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));
2424         /**
2425          * {@inheritDoc}
2426          */
2427         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));
2428         /**
2429          * {@inheritDoc}
2430          */
2431         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));
2432         /**
2433          * {@inheritDoc}
2434          */
2435         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));
2436 }
2437
2438
2439 static void gee_linked_list_gee_queue_interface_init (GeeQueueIface * iface) {
2440         gee_linked_list_gee_queue_parent_iface = g_type_interface_peek_parent (iface);
2441         iface->offer = (gboolean (*)(GeeQueue*, gconstpointer)) gee_linked_list_real_offer;
2442         iface->peek = (gpointer (*)(GeeQueue*)) gee_linked_list_real_peek;
2443         iface->poll = (gpointer (*)(GeeQueue*)) gee_linked_list_real_poll;
2444         iface->drain = (gint (*)(GeeQueue*, GeeCollection*, gint)) gee_linked_list_real_drain;
2445         iface->get_capacity = gee_linked_list_real_get_capacity;
2446         iface->get_remaining_capacity = gee_linked_list_real_get_remaining_capacity;
2447         iface->get_is_full = gee_linked_list_real_get_is_full;
2448 }
2449
2450
2451 static void gee_linked_list_gee_deque_interface_init (GeeDequeIface * iface) {
2452         gee_linked_list_gee_deque_parent_iface = g_type_interface_peek_parent (iface);
2453         iface->offer_head = (gboolean (*)(GeeDeque*, gconstpointer)) gee_linked_list_real_offer_head;
2454         iface->peek_head = (gpointer (*)(GeeDeque*)) gee_linked_list_real_peek_head;
2455         iface->poll_head = (gpointer (*)(GeeDeque*)) gee_linked_list_real_poll_head;
2456         iface->drain_head = (gint (*)(GeeDeque*, GeeCollection*, gint)) gee_linked_list_real_drain_head;
2457         iface->offer_tail = (gboolean (*)(GeeDeque*, gconstpointer)) gee_linked_list_real_offer_tail;
2458         iface->peek_tail = (gpointer (*)(GeeDeque*)) gee_linked_list_real_peek_tail;
2459         iface->poll_tail = (gpointer (*)(GeeDeque*)) gee_linked_list_real_poll_tail;
2460         iface->drain_tail = (gint (*)(GeeDeque*, GeeCollection*, gint)) gee_linked_list_real_drain_tail;
2461 }
2462
2463
2464 static void gee_linked_list_instance_init (GeeLinkedList * self) {
2465         self->priv = GEE_LINKED_LIST_GET_PRIVATE (self);
2466         self->priv->_size = 0;
2467         self->priv->_stamp = 0;
2468         self->priv->_head = NULL;
2469         self->priv->_tail = NULL;
2470 }
2471
2472
2473 static void gee_linked_list_finalize (GObject* obj) {
2474         GeeLinkedList * self;
2475         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_LINKED_LIST, GeeLinkedList);
2476         gee_abstract_collection_clear ((GeeAbstractCollection*) self);
2477         _gee_linked_list_node_free0 (self->priv->_head);
2478         G_OBJECT_CLASS (gee_linked_list_parent_class)->finalize (obj);
2479 }
2480
2481
2482 /**
2483  * Doubly-linked list implementation of the {@link List} interface.
2484  *
2485  * This implementation is pretty well designed for highly mutable data. When
2486  * indexed access is privileged prefer using {@link ArrayList}.
2487  *
2488  * @see ArrayList
2489  */
2490 GType gee_linked_list_get_type (void) {
2491         static volatile gsize gee_linked_list_type_id__volatile = 0;
2492         if (g_once_init_enter (&gee_linked_list_type_id__volatile)) {
2493                 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 };
2494                 static const GInterfaceInfo gee_queue_info = { (GInterfaceInitFunc) gee_linked_list_gee_queue_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2495                 static const GInterfaceInfo gee_deque_info = { (GInterfaceInitFunc) gee_linked_list_gee_deque_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2496                 GType gee_linked_list_type_id;
2497                 gee_linked_list_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_LIST, "GeeLinkedList", &g_define_type_info, 0);
2498                 g_type_add_interface_static (gee_linked_list_type_id, GEE_TYPE_QUEUE, &gee_queue_info);
2499                 g_type_add_interface_static (gee_linked_list_type_id, GEE_TYPE_DEQUE, &gee_deque_info);
2500                 g_once_init_leave (&gee_linked_list_type_id__volatile, gee_linked_list_type_id);
2501         }
2502         return gee_linked_list_type_id__volatile;
2503 }
2504
2505
2506 static void _vala_gee_linked_list_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2507         GeeLinkedList * self;
2508         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_LINKED_LIST, GeeLinkedList);
2509         switch (property_id) {
2510                 case GEE_LINKED_LIST_EQUAL_FUNC:
2511                 g_value_set_pointer (value, gee_linked_list_get_equal_func (self));
2512                 break;
2513                 case GEE_LINKED_LIST_SIZE:
2514                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
2515                 break;
2516                 case GEE_LINKED_LIST_CAPACITY:
2517                 g_value_set_int (value, gee_queue_get_capacity ((GeeQueue*) self));
2518                 break;
2519                 case GEE_LINKED_LIST_REMAINING_CAPACITY:
2520                 g_value_set_int (value, gee_queue_get_remaining_capacity ((GeeQueue*) self));
2521                 break;
2522                 case GEE_LINKED_LIST_IS_FULL:
2523                 g_value_set_boolean (value, gee_queue_get_is_full ((GeeQueue*) self));
2524                 break;
2525                 default:
2526                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2527                 break;
2528         }
2529 }
2530
2531
2532 static void _vala_gee_linked_list_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2533         GeeLinkedList * self;
2534         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_LINKED_LIST, GeeLinkedList);
2535         switch (property_id) {
2536                 case GEE_LINKED_LIST_EQUAL_FUNC:
2537                 gee_linked_list_set_equal_func (self, g_value_get_pointer (value));
2538                 break;
2539                 case GEE_LINKED_LIST_G_TYPE:
2540                 self->priv->g_type = g_value_get_gtype (value);
2541                 break;
2542                 case GEE_LINKED_LIST_G_DUP_FUNC:
2543                 self->priv->g_dup_func = g_value_get_pointer (value);
2544                 break;
2545                 case GEE_LINKED_LIST_G_DESTROY_FUNC:
2546                 self->priv->g_destroy_func = g_value_get_pointer (value);
2547                 break;
2548                 default:
2549                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2550                 break;
2551         }
2552 }
2553
2554
2555