gee/priorityqueue.c

   1 /* priorityqueue.c generated by valac 0.18.0, the Vala compiler
   2  * generated from priorityqueue.vala, do not modify */
   3
   4 /* priorityqueue.vala
   5  *
   6  * Copyright (C) 2009  Didier Villevalois
   7  * Copyright (C) 2012  Maciej Piechotka
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  22  *
  23  * Author:
  24  *      Didier 'Ptitjes Villevalois <ptitjes@free.fr>
  25  */
  26
  27 #include <glib.h>
  28 #include <glib-object.h>
  29 #include <string.h>
  30 #include <gobject/gvaluecollector.h>
  31
  32
  33 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  34 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  35 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  36 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  37
  38 typedef struct _GeeTraversable GeeTraversable;
  39 typedef struct _GeeTraversableIface GeeTraversableIface;
  40
  41 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  42
  43 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  44 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  45 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  46 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  47 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  48 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  49
  50 typedef struct _GeeLazy GeeLazy;
  51 typedef struct _GeeLazyClass GeeLazyClass;
  52
  53 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  54 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  55 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  56 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  57
  58 typedef struct _GeeIterator GeeIterator;
  59 typedef struct _GeeIteratorIface GeeIteratorIface;
  60
  61 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  62 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  63 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  64 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  65
  66 typedef struct _GeeIterable GeeIterable;
  67 typedef struct _GeeIterableIface GeeIterableIface;
  68
  69 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  70 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  71 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  72 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  73
  74 typedef struct _GeeCollection GeeCollection;
  75 typedef struct _GeeCollectionIface GeeCollectionIface;
  76
  77 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
  78 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
  79 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  80 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
  81 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
  82 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  83
  84 typedef struct _GeeAbstractCollection GeeAbstractCollection;
  85 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
  86 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
  87
  88 #define GEE_TYPE_QUEUE (gee_queue_get_type ())
  89 #define GEE_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_QUEUE, GeeQueue))
  90 #define GEE_IS_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_QUEUE))
  91 #define GEE_QUEUE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_QUEUE, GeeQueueIface))
  92
  93 typedef struct _GeeQueue GeeQueue;
  94 typedef struct _GeeQueueIface GeeQueueIface;
  95
  96 #define GEE_TYPE_ABSTRACT_QUEUE (gee_abstract_queue_get_type ())
  97 #define GEE_ABSTRACT_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_QUEUE, GeeAbstractQueue))
  98 #define GEE_ABSTRACT_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_QUEUE, GeeAbstractQueueClass))
  99 #define GEE_IS_ABSTRACT_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_QUEUE))
 100 #define GEE_IS_ABSTRACT_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_QUEUE))
 101 #define GEE_ABSTRACT_QUEUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_QUEUE, GeeAbstractQueueClass))
 102
 103 typedef struct _GeeAbstractQueue GeeAbstractQueue;
 104 typedef struct _GeeAbstractQueueClass GeeAbstractQueueClass;
 105 typedef struct _GeeAbstractQueuePrivate GeeAbstractQueuePrivate;
 106
 107 #define GEE_TYPE_PRIORITY_QUEUE (gee_priority_queue_get_type ())
 108 #define GEE_PRIORITY_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_PRIORITY_QUEUE, GeePriorityQueue))
 109 #define GEE_PRIORITY_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_PRIORITY_QUEUE, GeePriorityQueueClass))
 110 #define GEE_IS_PRIORITY_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_PRIORITY_QUEUE))
 111 #define GEE_IS_PRIORITY_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_PRIORITY_QUEUE))
 112 #define GEE_PRIORITY_QUEUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_PRIORITY_QUEUE, GeePriorityQueueClass))
 113
 114 typedef struct _GeePriorityQueue GeePriorityQueue;
 115 typedef struct _GeePriorityQueueClass GeePriorityQueueClass;
 116 typedef struct _GeePriorityQueuePrivate GeePriorityQueuePrivate;
 117
 118 #define GEE_PRIORITY_QUEUE_TYPE_NODE (gee_priority_queue_node_get_type ())
 119 #define GEE_PRIORITY_QUEUE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode))
 120 #define GEE_PRIORITY_QUEUE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNodeClass))
 121 #define GEE_PRIORITY_QUEUE_IS_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_PRIORITY_QUEUE_TYPE_NODE))
 122 #define GEE_PRIORITY_QUEUE_IS_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_PRIORITY_QUEUE_TYPE_NODE))
 123 #define GEE_PRIORITY_QUEUE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNodeClass))
 124
 125 typedef struct _GeePriorityQueueNode GeePriorityQueueNode;
 126 typedef struct _GeePriorityQueueNodeClass GeePriorityQueueNodeClass;
 127
 128 #define GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE (gee_priority_queue_type1_node_get_type ())
 129 #define GEE_PRIORITY_QUEUE_TYPE1_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node))
 130 #define GEE_PRIORITY_QUEUE_TYPE1_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1NodeClass))
 131 #define GEE_PRIORITY_QUEUE_IS_TYPE1_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE))
 132 #define GEE_PRIORITY_QUEUE_IS_TYPE1_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE))
 133 #define GEE_PRIORITY_QUEUE_TYPE1_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1NodeClass))
 134
 135 typedef struct _GeePriorityQueueType1Node GeePriorityQueueType1Node;
 136 typedef struct _GeePriorityQueueType1NodeClass GeePriorityQueueType1NodeClass;
 137
 138 #define GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE (gee_priority_queue_type2_node_get_type ())
 139 #define GEE_PRIORITY_QUEUE_TYPE2_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE, GeePriorityQueueType2Node))
 140 #define GEE_PRIORITY_QUEUE_TYPE2_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE, GeePriorityQueueType2NodeClass))
 141 #define GEE_PRIORITY_QUEUE_IS_TYPE2_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE))
 142 #define GEE_PRIORITY_QUEUE_IS_TYPE2_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE))
 143 #define GEE_PRIORITY_QUEUE_TYPE2_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE, GeePriorityQueueType2NodeClass))
 144
 145 typedef struct _GeePriorityQueueType2Node GeePriorityQueueType2Node;
 146 typedef struct _GeePriorityQueueType2NodeClass GeePriorityQueueType2NodeClass;
 147 typedef struct _GeePriorityQueueNodePair GeePriorityQueueNodePair;
 148 #define _gee_priority_queue_node_unref0(var) ((var == NULL) ? NULL : (var = (gee_priority_queue_node_unref (var), NULL)))
 149 #define _gee_priority_queue_node_pair_free0(var) ((var == NULL) ? NULL : (var = (gee_priority_queue_node_pair_free (var), NULL)))
 150 typedef struct _GeePriorityQueueNodePrivate GeePriorityQueueNodePrivate;
 151 typedef struct _GeePriorityQueueType1NodePrivate GeePriorityQueueType1NodePrivate;
 152 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 153
 154 #define GEE_PRIORITY_QUEUE_TYPE_ITERATOR (gee_priority_queue_iterator_get_type ())
 155 #define GEE_PRIORITY_QUEUE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_PRIORITY_QUEUE_TYPE_ITERATOR, GeePriorityQueueIterator))
 156 #define GEE_PRIORITY_QUEUE_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_PRIORITY_QUEUE_TYPE_ITERATOR, GeePriorityQueueIteratorClass))
 157 #define GEE_PRIORITY_QUEUE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_PRIORITY_QUEUE_TYPE_ITERATOR))
 158 #define GEE_PRIORITY_QUEUE_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_PRIORITY_QUEUE_TYPE_ITERATOR))
 159 #define GEE_PRIORITY_QUEUE_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_PRIORITY_QUEUE_TYPE_ITERATOR, GeePriorityQueueIteratorClass))
 160
 161 typedef struct _GeePriorityQueueIterator GeePriorityQueueIterator;
 162 typedef struct _GeePriorityQueueIteratorClass GeePriorityQueueIteratorClass;
 163 #define _g_destroy_func0(var) (((var == NULL) || (g_destroy_func == NULL)) ? NULL : (var = (g_destroy_func (var), NULL)))
 164 typedef struct _GeePriorityQueueParamSpecNode GeePriorityQueueParamSpecNode;
 165 typedef struct _GeePriorityQueueType2NodePrivate GeePriorityQueueType2NodePrivate;
 166
 167 #define GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE (gee_priority_queue_dummy_node_get_type ())
 168 #define GEE_PRIORITY_QUEUE_DUMMY_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE, GeePriorityQueueDummyNode))
 169 #define GEE_PRIORITY_QUEUE_DUMMY_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE, GeePriorityQueueDummyNodeClass))
 170 #define GEE_PRIORITY_QUEUE_IS_DUMMY_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE))
 171 #define GEE_PRIORITY_QUEUE_IS_DUMMY_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE))
 172 #define GEE_PRIORITY_QUEUE_DUMMY_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE, GeePriorityQueueDummyNodeClass))
 173
 174 typedef struct _GeePriorityQueueDummyNode GeePriorityQueueDummyNode;
 175 typedef struct _GeePriorityQueueDummyNodeClass GeePriorityQueueDummyNodeClass;
 176 typedef struct _GeePriorityQueueDummyNodePrivate GeePriorityQueueDummyNodePrivate;
 177 typedef struct _GeePriorityQueueIteratorPrivate GeePriorityQueueIteratorPrivate;
 178 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 179
 180 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 181 typedef enum  {
 182         GEE_TRAVERSABLE_STREAM_YIELD,
 183         GEE_TRAVERSABLE_STREAM_CONTINUE,
 184         GEE_TRAVERSABLE_STREAM_END
 185 } GeeTraversableStream;
 186
 187 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 188 struct _GeeIteratorIface {
 189         GTypeInterface parent_iface;
 190         gboolean (*next) (GeeIterator* self);
 191         gboolean (*has_next) (GeeIterator* self);
 192         gpointer (*get) (GeeIterator* self);
 193         void (*remove) (GeeIterator* self);
 194         gboolean (*get_valid) (GeeIterator* self);
 195         gboolean (*get_read_only) (GeeIterator* self);
 196 };
 197
 198 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 199 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 200 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 201 struct _GeeTraversableIface {
 202         GTypeInterface parent_iface;
 203         GType (*get_g_type) (GeeTraversable* self);
 204         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 205         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 206         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 207         GeeIterator* (*stream) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 208         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 209         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 210         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 211         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 212         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 213         GType (*get_element_type) (GeeTraversable* self);
 214 };
 215
 216 struct _GeeIterableIface {
 217         GTypeInterface parent_iface;
 218         GType (*get_g_type) (GeeIterable* self);
 219         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 220         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 221         GeeIterator* (*iterator) (GeeIterable* self);
 222 };
 223
 224 struct _GeeCollectionIface {
 225         GTypeInterface parent_iface;
 226         GType (*get_g_type) (GeeCollection* self);
 227         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 228         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 229         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 230         gboolean (*add) (GeeCollection* self, gconstpointer item);
 231         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 232         void (*clear) (GeeCollection* self);
 233         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 234         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 235         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 236         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 237         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 238         gint (*get_size) (GeeCollection* self);
 239         gboolean (*get_is_empty) (GeeCollection* self);
 240         gboolean (*get_read_only) (GeeCollection* self);
 241         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 242 };
 243
 244 struct _GeeAbstractCollection {
 245         GObject parent_instance;
 246         GeeAbstractCollectionPrivate * priv;
 247 };
 248
 249 struct _GeeAbstractCollectionClass {
 250         GObjectClass parent_class;
 251         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 252         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 253         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 254         void (*clear) (GeeAbstractCollection* self);
 255         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 256         gboolean (*foreach) (GeeAbstractCollection* self, GeeForallFunc f, void* f_target);
 257         void (*reserved0) (GeeAbstractCollection* self);
 258         void (*reserved1) (GeeAbstractCollection* self);
 259         void (*reserved2) (GeeAbstractCollection* self);
 260         void (*reserved3) (GeeAbstractCollection* self);
 261         void (*reserved4) (GeeAbstractCollection* self);
 262         void (*reserved5) (GeeAbstractCollection* self);
 263         void (*reserved6) (GeeAbstractCollection* self);
 264         void (*reserved7) (GeeAbstractCollection* self);
 265         void (*reserved8) (GeeAbstractCollection* self);
 266         void (*reserved9) (GeeAbstractCollection* self);
 267         gint (*get_size) (GeeAbstractCollection* self);
 268         gboolean (*get_read_only) (GeeAbstractCollection* self);
 269         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 270 };
 271
 272 struct _GeeQueueIface {
 273         GTypeInterface parent_iface;
 274         GType (*get_g_type) (GeeQueue* self);
 275         GBoxedCopyFunc (*get_g_dup_func) (GeeQueue* self);
 276         GDestroyNotify (*get_g_destroy_func) (GeeQueue* self);
 277         gboolean (*offer) (GeeQueue* self, gconstpointer element);
 278         gpointer (*peek) (GeeQueue* self);
 279         gpointer (*poll) (GeeQueue* self);
 280         gint (*drain) (GeeQueue* self, GeeCollection* recipient, gint amount);
 281         gint (*get_capacity) (GeeQueue* self);
 282         gint (*get_remaining_capacity) (GeeQueue* self);
 283         gboolean (*get_is_full) (GeeQueue* self);
 284 };
 285
 286 struct _GeeAbstractQueue {
 287         GeeAbstractCollection parent_instance;
 288         GeeAbstractQueuePrivate * priv;
 289 };
 290
 291 struct _GeeAbstractQueueClass {
 292         GeeAbstractCollectionClass parent_class;
 293         gpointer (*peek) (GeeAbstractQueue* self);
 294         gpointer (*poll) (GeeAbstractQueue* self);
 295         void (*reserved0) (GeeAbstractQueue* self);
 296         void (*reserved1) (GeeAbstractQueue* self);
 297         void (*reserved2) (GeeAbstractQueue* self);
 298         void (*reserved3) (GeeAbstractQueue* self);
 299         void (*reserved4) (GeeAbstractQueue* self);
 300         void (*reserved5) (GeeAbstractQueue* self);
 301         void (*reserved6) (GeeAbstractQueue* self);
 302         void (*reserved7) (GeeAbstractQueue* self);
 303         void (*reserved8) (GeeAbstractQueue* self);
 304         void (*reserved9) (GeeAbstractQueue* self);
 305         gint (*get_capacity) (GeeAbstractQueue* self);
 306         gint (*get_remaining_capacity) (GeeAbstractQueue* self);
 307         gboolean (*get_is_full) (GeeAbstractQueue* self);
 308 };
 309
 310 struct _GeePriorityQueue {
 311         GeeAbstractQueue parent_instance;
 312         GeePriorityQueuePrivate * priv;
 313 };
 314
 315 struct _GeePriorityQueueClass {
 316         GeeAbstractQueueClass parent_class;
 317 };
 318
 319 struct _GeePriorityQueuePrivate {
 320         GType g_type;
 321         GBoxedCopyFunc g_dup_func;
 322         GDestroyNotify g_destroy_func;
 323         GCompareDataFunc _compare_func;
 324         gpointer _compare_func_target;
 325         GDestroyNotify _compare_func_target_destroy_notify;
 326         gint _size;
 327         gint _stamp;
 328         GeePriorityQueueType1Node* _r;
 329         GeePriorityQueueType2Node* _r_prime;
 330         GeePriorityQueueType2Node* _lm_head;
 331         GeePriorityQueueType2Node* _lm_tail;
 332         GeePriorityQueueType1Node* _p;
 333         GeePriorityQueueType1Node** _a;
 334         gint _a_length1;
 335         gint __a_size_;
 336         GeePriorityQueueNodePair* _lp_head;
 337         GeePriorityQueueNodePair* _lp_tail;
 338         gboolean* _b;
 339         gint _b_length1;
 340         gint __b_size_;
 341         GeePriorityQueueType1Node* _ll_head;
 342         GeePriorityQueueType1Node* _ll_tail;
 343         GeePriorityQueueNode* _iter_head;
 344         GeePriorityQueueNode* _iter_tail;
 345 };
 346
 347 struct _GeePriorityQueueNode {
 348         GTypeInstance parent_instance;
 349         volatile int ref_count;
 350         GeePriorityQueueNodePrivate * priv;
 351         gpointer data;
 352         GeePriorityQueueNode* parent;
 353         gint type1_children_count;
 354         GeePriorityQueueType1Node* type1_children_head;
 355         GeePriorityQueueType1Node* type1_children_tail;
 356         GeePriorityQueueNode* iter_prev;
 357         GeePriorityQueueNode* iter_next;
 358         gboolean pending_drop;
 359 };
 360
 361 struct _GeePriorityQueueNodeClass {
 362         GTypeClass parent_class;
 363         void (*finalize) (GeePriorityQueueNode *self);
 364 };
 365
 366 struct _GeePriorityQueueType1Node {
 367         GeePriorityQueueNode parent_instance;
 368         GeePriorityQueueType1NodePrivate * priv;
 369         guint lost;
 370         GeePriorityQueueType1Node* brothers_prev;
 371         GeePriorityQueueType1Node* brothers_next;
 372         GeePriorityQueueType2Node* type2_child;
 373         GeePriorityQueueType1Node* ll_prev;
 374         GeePriorityQueueType1Node* ll_next;
 375         GeePriorityQueueNodePair* pair;
 376 };
 377
 378 struct _GeePriorityQueueType1NodeClass {
 379         GeePriorityQueueNodeClass parent_class;
 380 };
 381
 382 struct _GeePriorityQueueNodePair {
 383         GeePriorityQueueNodePair* lp_prev;
 384         GeePriorityQueueNodePair* lp_next;
 385         GeePriorityQueueType1Node* node1;
 386         GeePriorityQueueType1Node* node2;
 387 };
 388
 389 struct _GeePriorityQueueNodePrivate {
 390         GType g_type;
 391         GBoxedCopyFunc g_dup_func;
 392         GDestroyNotify g_destroy_func;
 393 };
 394
 395 struct _GeePriorityQueueParamSpecNode {
 396         GParamSpec parent_instance;
 397 };
 398
 399 struct _GeePriorityQueueType1NodePrivate {
 400         GType g_type;
 401         GBoxedCopyFunc g_dup_func;
 402         GDestroyNotify g_destroy_func;
 403 };
 404
 405 struct _GeePriorityQueueType2Node {
 406         GeePriorityQueueNode parent_instance;
 407         GeePriorityQueueType2NodePrivate * priv;
 408 };
 409
 410 struct _GeePriorityQueueType2NodeClass {
 411         GeePriorityQueueNodeClass parent_class;
 412 };
 413
 414 struct _GeePriorityQueueType2NodePrivate {
 415         GType g_type;
 416         GBoxedCopyFunc g_dup_func;
 417         GDestroyNotify g_destroy_func;
 418 };
 419
 420 struct _GeePriorityQueueDummyNode {
 421         GeePriorityQueueNode parent_instance;
 422         GeePriorityQueueDummyNodePrivate * priv;
 423 };
 424
 425 struct _GeePriorityQueueDummyNodeClass {
 426         GeePriorityQueueNodeClass parent_class;
 427 };
 428
 429 struct _GeePriorityQueueDummyNodePrivate {
 430         GType g_type;
 431         GBoxedCopyFunc g_dup_func;
 432         GDestroyNotify g_destroy_func;
 433 };
 434
 435 struct _GeePriorityQueueIterator {
 436         GObject parent_instance;
 437         GeePriorityQueueIteratorPrivate * priv;
 438 };
 439
 440 struct _GeePriorityQueueIteratorClass {
 441         GObjectClass parent_class;
 442 };
 443
 444 struct _GeePriorityQueueIteratorPrivate {
 445         GType g_type;
 446         GBoxedCopyFunc g_dup_func;
 447         GDestroyNotify g_destroy_func;
 448         GeePriorityQueue* queue;
 449         GeePriorityQueueNode* position;
 450         GeePriorityQueueNode* previous;
 451         gint stamp;
 452 };
 453
 454
 455 static gpointer gee_priority_queue_parent_class = NULL;
 456 static gpointer gee_priority_queue_node_parent_class = NULL;
 457 static gpointer gee_priority_queue_type1_node_parent_class = NULL;
 458 static gpointer gee_priority_queue_type2_node_parent_class = NULL;
 459 static gpointer gee_priority_queue_dummy_node_parent_class = NULL;
 460 static gpointer gee_priority_queue_iterator_parent_class = NULL;
 461 static GeeTraversableIface* gee_priority_queue_iterator_gee_traversable_parent_iface = NULL;
 462 static GeeIteratorIface* gee_priority_queue_iterator_gee_iterator_parent_iface = NULL;
 463
 464 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 465 gpointer gee_lazy_ref (gpointer instance);
 466 void gee_lazy_unref (gpointer instance);
 467 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 468 void gee_value_set_lazy (GValue* value, gpointer v_object);
 469 void gee_value_take_lazy (GValue* value, gpointer v_object);
 470 gpointer gee_value_get_lazy (const GValue* value);
 471 GType gee_lazy_get_type (void) G_GNUC_CONST;
 472 GType gee_iterator_get_type (void) G_GNUC_CONST;
 473 GType gee_traversable_get_type (void) G_GNUC_CONST;
 474 GType gee_iterable_get_type (void) G_GNUC_CONST;
 475 GType gee_collection_get_type (void) G_GNUC_CONST;
 476 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 477 GType gee_queue_get_type (void) G_GNUC_CONST;
 478 GType gee_abstract_queue_get_type (void) G_GNUC_CONST;
 479 GType gee_priority_queue_get_type (void) G_GNUC_CONST;
 480 static gpointer gee_priority_queue_node_ref (gpointer instance);
 481 static void gee_priority_queue_node_unref (gpointer instance);
 482 static GParamSpec* gee_priority_queue_param_spec_node (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
 483 static void gee_priority_queue_value_set_node (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 484 static void gee_priority_queue_value_take_node (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 485 static gpointer gee_priority_queue_value_get_node (const GValue* value) G_GNUC_UNUSED;
 486 static GType gee_priority_queue_node_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 487 static GType gee_priority_queue_type1_node_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 488 static GType gee_priority_queue_type2_node_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 489 static void gee_priority_queue_node_pair_free (GeePriorityQueueNodePair* self);
 490 #define GEE_PRIORITY_QUEUE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_PRIORITY_QUEUE, GeePriorityQueuePrivate))
 491 enum  {
 492         GEE_PRIORITY_QUEUE_DUMMY_PROPERTY,
 493         GEE_PRIORITY_QUEUE_G_TYPE,
 494         GEE_PRIORITY_QUEUE_G_DUP_FUNC,
 495         GEE_PRIORITY_QUEUE_G_DESTROY_FUNC,
 496         GEE_PRIORITY_QUEUE_CAPACITY,
 497         GEE_PRIORITY_QUEUE_REMAINING_CAPACITY,
 498         GEE_PRIORITY_QUEUE_IS_FULL,
 499         GEE_PRIORITY_QUEUE_READ_ONLY,
 500         GEE_PRIORITY_QUEUE_SIZE
 501 };
 502 GeePriorityQueue* gee_priority_queue_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify);
 503 GeePriorityQueue* gee_priority_queue_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify);
 504 GeeAbstractQueue* gee_abstract_queue_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 505 GCompareDataFunc gee_functions_get_compare_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
 506 static void gee_priority_queue_set_compare_func (GeePriorityQueue* self, GCompareDataFunc value, gpointer value_target);
 507 gboolean gee_priority_queue_offer (GeePriorityQueue* self, gconstpointer element);
 508 static GeePriorityQueueType1Node* gee_priority_queue_type1_node_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail);
 509 static GeePriorityQueueType1Node* gee_priority_queue_type1_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail);
 510 static GeePriorityQueueType2Node* gee_priority_queue_type2_node_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail);
 511 static GeePriorityQueueType2Node* gee_priority_queue_type2_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail);
 512 static inline gint _gee_priority_queue_compare (GeePriorityQueue* self, GeePriorityQueueNode* node1, GeePriorityQueueNode* node2);
 513 static inline void _gee_priority_queue_swap_data (GeePriorityQueue* self, GeePriorityQueueNode* node1, GeePriorityQueueNode* node2);
 514 static void _gee_priority_queue_add (GeePriorityQueue* self, GeePriorityQueueType1Node* n);
 515 static gpointer gee_priority_queue_real_peek (GeeAbstractQueue* base);
 516 static gpointer gee_priority_queue_real_poll (GeeAbstractQueue* base);
 517 static inline void _gee_priority_queue_move_data (GeePriorityQueue* self, GeePriorityQueueNode* target, GeePriorityQueueNode* source);
 518 static void _gee_priority_queue_remove_type2_node (GeePriorityQueue* self, GeePriorityQueueType2Node* node, gboolean with_iteration);
 519 static void _gee_priority_queue_remove_type1_node (GeePriorityQueue* self, GeePriorityQueueType1Node* node, gboolean with_iteration);
 520 static void _gee_priority_queue_add_in_r_prime (GeePriorityQueue* self, GeePriorityQueueType1Node* node);
 521 static void _gee_priority_queue_adjust (GeePriorityQueue* self, GeePriorityQueueType1Node* p1, GeePriorityQueueType1Node* p2);
 522 static gboolean _gee_priority_queue_check_linkable (GeePriorityQueue* self);
 523 gint gee_priority_queue_drain (GeePriorityQueue* self, GeeCollection* recipient, gint amount);
 524 gboolean gee_collection_add (GeeCollection* self, gconstpointer item);
 525 gpointer gee_abstract_queue_poll (GeeAbstractQueue* self);
 526 static gboolean gee_priority_queue_real_contains (GeeAbstractCollection* base, gconstpointer item);
 527 GeeIterator* gee_abstract_collection_iterator (GeeAbstractCollection* self);
 528 gboolean gee_iterator_next (GeeIterator* self);
 529 gpointer gee_iterator_get (GeeIterator* self);
 530 GCompareDataFunc gee_priority_queue_get_compare_func (GeePriorityQueue* self, gpointer* result_target);
 531 static gboolean gee_priority_queue_real_add (GeeAbstractCollection* base, gconstpointer item);
 532 static gboolean gee_priority_queue_real_remove (GeeAbstractCollection* base, gconstpointer item);
 533 static GeePriorityQueueIterator* gee_priority_queue_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueue* queue);
 534 static GeePriorityQueueIterator* gee_priority_queue_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueue* queue);
 535 static GType gee_priority_queue_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 536 void gee_iterator_remove (GeeIterator* self);
 537 static void gee_priority_queue_real_clear (GeeAbstractCollection* base);
 538 static GeeIterator* gee_priority_queue_real_iterator (GeeAbstractCollection* base);
 539 static void _gee_priority_queue_link (GeePriorityQueue* self, GeePriorityQueueType1Node* ri, GeePriorityQueueType1Node* rj);
 540 static inline gint gee_priority_queue_node_degree (GeePriorityQueueNode* self);
 541 static void _gee_priority_queue_add_to (GeePriorityQueue* self, GeePriorityQueueType1Node* node, GeePriorityQueueType1Node* parent);
 542 static GeePriorityQueueNode* _gee_priority_queue_re_insert (GeePriorityQueue* self, GeePriorityQueueType1Node* n);
 543 static void _gee_priority_queue_delete (GeePriorityQueue* self, GeePriorityQueueNode* n);
 544 static void _gee_priority_queue_decrease_key (GeePriorityQueue* self, GeePriorityQueueNode* n);
 545 static inline void gee_priority_queue_type1_node_add (GeePriorityQueueType1Node* self, GeePriorityQueueType1Node* node);
 546 static GeePriorityQueueNodePair* gee_priority_queue_node_pair_new (GeePriorityQueueType1Node* node1, GeePriorityQueueType1Node* node2);
 547 static GeePriorityQueueNodePair* gee_priority_queue_node_pair_new (GeePriorityQueueType1Node* node1, GeePriorityQueueType1Node* node2);
 548 static void _gee_priority_queue_updated_degree (GeePriorityQueue* self, GeePriorityQueueType1Node* node, gboolean child_removed);
 549 static inline void gee_priority_queue_type1_node_remove (GeePriorityQueueType1Node* self);
 550 #define GEE_QUEUE_UNBOUNDED_CAPACITY (-1)
 551 #define GEE_PRIORITY_QUEUE_NODE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNodePrivate))
 552 enum  {
 553         GEE_PRIORITY_QUEUE_NODE_DUMMY_PROPERTY
 554 };
 555 static GeePriorityQueueNode* gee_priority_queue_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail);
 556 static void gee_priority_queue_node_finalize (GeePriorityQueueNode* obj);
 557 #define GEE_PRIORITY_QUEUE_TYPE1_NODE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1NodePrivate))
 558 enum  {
 559         GEE_PRIORITY_QUEUE_TYPE1_NODE_DUMMY_PROPERTY
 560 };
 561 static void gee_priority_queue_type1_node_finalize (GeePriorityQueueNode* obj);
 562 #define GEE_PRIORITY_QUEUE_TYPE2_NODE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE, GeePriorityQueueType2NodePrivate))
 563 enum  {
 564         GEE_PRIORITY_QUEUE_TYPE2_NODE_DUMMY_PROPERTY
 565 };
 566 static GType gee_priority_queue_dummy_node_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 567 #define GEE_PRIORITY_QUEUE_DUMMY_NODE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE, GeePriorityQueueDummyNodePrivate))
 568 enum  {
 569         GEE_PRIORITY_QUEUE_DUMMY_NODE_DUMMY_PROPERTY
 570 };
 571 static GeePriorityQueueDummyNode* gee_priority_queue_dummy_node_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueueNode** prev_next, GeePriorityQueueNode** next_prev, GeePriorityQueueNode* iter_prev, GeePriorityQueueNode* iter_next);
 572 static GeePriorityQueueDummyNode* gee_priority_queue_dummy_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueueNode** prev_next, GeePriorityQueueNode** next_prev, GeePriorityQueueNode* iter_prev, GeePriorityQueueNode* iter_next);
 573 static void gee_priority_queue_node_pair_instance_init (GeePriorityQueueNodePair * self);
 574 #define GEE_PRIORITY_QUEUE_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_PRIORITY_QUEUE_TYPE_ITERATOR, GeePriorityQueueIteratorPrivate))
 575 enum  {
 576         GEE_PRIORITY_QUEUE_ITERATOR_DUMMY_PROPERTY,
 577         GEE_PRIORITY_QUEUE_ITERATOR_G_TYPE,
 578         GEE_PRIORITY_QUEUE_ITERATOR_G_DUP_FUNC,
 579         GEE_PRIORITY_QUEUE_ITERATOR_G_DESTROY_FUNC,
 580         GEE_PRIORITY_QUEUE_ITERATOR_READ_ONLY,
 581         GEE_PRIORITY_QUEUE_ITERATOR_VALID
 582 };
 583 static gboolean gee_priority_queue_iterator_real_next (GeeIterator* base);
 584 static inline GeePriorityQueueNode* _gee_priority_queue_iterator_get_next_node (GeePriorityQueueIterator* self);
 585 static gboolean gee_priority_queue_iterator_real_has_next (GeeIterator* base);
 586 static gpointer gee_priority_queue_iterator_real_get (GeeIterator* base);
 587 static void gee_priority_queue_iterator_real_remove (GeeIterator* base);
 588 static gboolean gee_priority_queue_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 589 static void gee_priority_queue_iterator_finalize (GObject* obj);
 590 gboolean gee_iterator_get_read_only (GeeIterator* self);
 591 gboolean gee_iterator_get_valid (GeeIterator* self);
 592 static void _vala_gee_priority_queue_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 593 static void _vala_gee_priority_queue_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 594 static void gee_priority_queue_finalize (GObject* obj);
 595 gint gee_abstract_queue_get_capacity (GeeAbstractQueue* self);
 596 gint gee_abstract_queue_get_remaining_capacity (GeeAbstractQueue* self);
 597 gboolean gee_abstract_queue_get_is_full (GeeAbstractQueue* self);
 598 gboolean gee_abstract_collection_get_read_only (GeeAbstractCollection* self);
 599 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 600 static void _vala_gee_priority_queue_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 601 static void _vala_gee_priority_queue_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 602 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 603 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 604
 605
 606 /**
 607  * Constructs a new, empty priority queue.
 608  *
 609  * If not provided, the function parameter is requested to the
 610  * {@link Functions} function factory methods.
 611  *
 612  * @param compare_func an optional element comparator function
 613  */
 614 GeePriorityQueue* gee_priority_queue_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify) {
 615         GeePriorityQueue * self = NULL;
 616         GCompareDataFunc _tmp0_;
 617         void* _tmp0__target;
 618         GCompareDataFunc _tmp4_;
 619         void* _tmp4__target;
 620         self = (GeePriorityQueue*) gee_abstract_queue_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
 621         self->priv->g_type = g_type;
 622         self->priv->g_dup_func = g_dup_func;
 623         self->priv->g_destroy_func = g_destroy_func;
 624         _tmp0_ = compare_func;
 625         _tmp0__target = compare_func_target;
 626         if (_tmp0_ == NULL) {
 627                 void* _tmp1_ = NULL;
 628                 GDestroyNotify _tmp2_ = NULL;
 629                 GCompareDataFunc _tmp3_ = NULL;
 630                 _tmp3_ = gee_functions_get_compare_func_for (g_type, &_tmp1_, &_tmp2_);
 631                 (compare_func_target_destroy_notify == NULL) ? NULL : (compare_func_target_destroy_notify (compare_func_target), NULL);
 632                 compare_func = NULL;
 633                 compare_func_target = NULL;
 634                 compare_func_target_destroy_notify = NULL;
 635                 compare_func = _tmp3_;
 636                 compare_func_target = _tmp1_;
 637                 compare_func_target_destroy_notify = _tmp2_;
 638         }
 639         _tmp4_ = compare_func;
 640         _tmp4__target = compare_func_target;
 641         gee_priority_queue_set_compare_func (self, _tmp4_, _tmp4__target);
 642         (compare_func_target_destroy_notify == NULL) ? NULL : (compare_func_target_destroy_notify (compare_func_target), NULL);
 643         compare_func = NULL;
 644         compare_func_target = NULL;
 645         compare_func_target_destroy_notify = NULL;
 646         return self;
 647 }
 648
 649
 650 GeePriorityQueue* gee_priority_queue_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify) {
 651         return gee_priority_queue_construct (GEE_TYPE_PRIORITY_QUEUE, g_type, g_dup_func, g_destroy_func, compare_func, compare_func_target, compare_func_target_destroy_notify);
 652 }
 653
 654
 655 /**
 656  * {@inheritDoc}
 657  */
 658 static gpointer _gee_priority_queue_node_ref0 (gpointer self) {
 659         return self ? gee_priority_queue_node_ref (self) : NULL;
 660 }
 661
 662
 663 gboolean gee_priority_queue_offer (GeePriorityQueue* self, gconstpointer element) {
 664         gboolean result = FALSE;
 665         GeePriorityQueueType1Node* _tmp0_;
 666         gint _tmp21_;
 667         gint _tmp22_;
 668         g_return_val_if_fail (self != NULL, FALSE);
 669         _tmp0_ = self->priv->_r;
 670         if (_tmp0_ == NULL) {
 671                 gconstpointer _tmp1_;
 672                 GeePriorityQueueType1Node* _tmp2_;
 673                 GeePriorityQueueType1Node* _tmp3_;
 674                 GeePriorityQueueType1Node* _tmp4_;
 675                 _tmp1_ = element;
 676                 _tmp2_ = gee_priority_queue_type1_node_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, &self->priv->_iter_head, &self->priv->_iter_tail);
 677                 _gee_priority_queue_node_unref0 (self->priv->_r);
 678                 self->priv->_r = _tmp2_;
 679                 _tmp3_ = self->priv->_r;
 680                 _tmp4_ = _gee_priority_queue_node_ref0 (_tmp3_);
 681                 _gee_priority_queue_node_unref0 (self->priv->_p);
 682                 self->priv->_p = _tmp4_;
 683         } else {
 684                 GeePriorityQueueType2Node* _tmp5_;
 685                 _tmp5_ = self->priv->_r_prime;
 686                 if (_tmp5_ == NULL) {
 687                         gconstpointer _tmp6_;
 688                         GeePriorityQueueType2Node* _tmp7_;
 689                         GeePriorityQueueType2Node* _tmp8_;
 690                         GeePriorityQueueType1Node* _tmp9_;
 691                         GeePriorityQueueType1Node* _tmp10_;
 692                         GeePriorityQueueType2Node* _tmp11_;
 693                         GeePriorityQueueType2Node* _tmp12_;
 694                         GeePriorityQueueType2Node* _tmp13_;
 695                         GeePriorityQueueType1Node* _tmp14_;
 696                         gint _tmp15_ = 0;
 697                         _tmp6_ = element;
 698                         _tmp7_ = gee_priority_queue_type2_node_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp6_, &self->priv->_iter_head, &self->priv->_iter_tail);
 699                         _gee_priority_queue_node_unref0 (self->priv->_r_prime);
 700                         self->priv->_r_prime = _tmp7_;
 701                         _tmp8_ = self->priv->_r_prime;
 702                         _tmp9_ = self->priv->_r;
 703                         ((GeePriorityQueueNode*) _tmp8_)->parent = (GeePriorityQueueNode*) _tmp9_;
 704                         _tmp10_ = self->priv->_r;
 705                         _tmp11_ = self->priv->_r_prime;
 706                         _tmp12_ = _gee_priority_queue_node_ref0 (_tmp11_);
 707                         _gee_priority_queue_node_unref0 (_tmp10_->type2_child);
 708                         _tmp10_->type2_child = _tmp12_;
 709                         _tmp13_ = self->priv->_r_prime;
 710                         _tmp14_ = self->priv->_r;
 711                         _tmp15_ = _gee_priority_queue_compare (self, (GeePriorityQueueNode*) _tmp13_, (GeePriorityQueueNode*) _tmp14_);
 712                         if (_tmp15_ < 0) {
 713                                 GeePriorityQueueType2Node* _tmp16_;
 714                                 GeePriorityQueueType1Node* _tmp17_;
 715                                 _tmp16_ = self->priv->_r_prime;
 716                                 _tmp17_ = self->priv->_r;
 717                                 _gee_priority_queue_swap_data (self, (GeePriorityQueueNode*) _tmp16_, (GeePriorityQueueNode*) _tmp17_);
 718                         }
 719                 } else {
 720                         gconstpointer _tmp18_;
 721                         GeePriorityQueueType1Node* _tmp19_;
 722                         GeePriorityQueueType1Node* node;
 723                         GeePriorityQueueType1Node* _tmp20_;
 724                         _tmp18_ = element;
 725                         _tmp19_ = gee_priority_queue_type1_node_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp18_, &self->priv->_iter_head, &self->priv->_iter_tail);
 726                         node = _tmp19_;
 727                         _tmp20_ = node;
 728                         _gee_priority_queue_add (self, _tmp20_);
 729                         _gee_priority_queue_node_unref0 (node);
 730                 }
 731         }
 732         _tmp21_ = self->priv->_stamp;
 733         self->priv->_stamp = _tmp21_ + 1;
 734         _tmp22_ = self->priv->_size;
 735         self->priv->_size = _tmp22_ + 1;
 736         result = TRUE;
 737         return result;
 738 }
 739
 740
 741 /**
 742  * {@inheritDoc}
 743  */
 744 static gpointer gee_priority_queue_real_peek (GeeAbstractQueue* base) {
 745         GeePriorityQueue * self;
 746         gpointer result = NULL;
 747         GeePriorityQueueType1Node* _tmp0_;
 748         GeePriorityQueueType1Node* _tmp1_;
 749         gconstpointer _tmp2_;
 750         gpointer _tmp3_;
 751         self = (GeePriorityQueue*) base;
 752         _tmp0_ = self->priv->_r;
 753         if (_tmp0_ == NULL) {
 754                 result = NULL;
 755                 return result;
 756         }
 757         _tmp1_ = self->priv->_r;
 758         _tmp2_ = ((GeePriorityQueueNode*) _tmp1_)->data;
 759         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
 760         result = _tmp3_;
 761         return result;
 762 }
 763
 764
 765 /**
 766  * {@inheritDoc}
 767  */
 768 static gpointer gee_priority_queue_real_poll (GeeAbstractQueue* base) {
 769         GeePriorityQueue * self;
 770         gpointer result = NULL;
 771         GeePriorityQueueType1Node* _tmp0_;
 772         GeePriorityQueueType1Node* _tmp1_;
 773         gconstpointer _tmp2_;
 774         gpointer _tmp3_;
 775         gpointer min;
 776         GeePriorityQueueType1Node* _tmp4_;
 777         gint _tmp5_;
 778         gint _tmp6_;
 779         GeePriorityQueueType2Node* _tmp7_;
 780         GeePriorityQueueType1Node* _tmp28_;
 781         GeePriorityQueueType2Node* _tmp29_;
 782         GeePriorityQueueType2Node* _tmp30_;
 783         GeePriorityQueueType1Node* _tmp31_;
 784         GeePriorityQueueType1Node* r_second;
 785         GeePriorityQueueType2Node* _tmp33_;
 786         GeePriorityQueueType1Node* _tmp34_;
 787         GeePriorityQueueType1Node* _tmp35_;
 788         GeePriorityQueueType1Node* node;
 789         GeePriorityQueueType2Node* _tmp48_;
 790         GeePriorityQueueType1Node* _tmp49_;
 791         GeePriorityQueueType1Node* _tmp50_;
 792         GeePriorityQueueType1Node* _tmp51_;
 793         GeePriorityQueueType1Node* _tmp52_;
 794         GeePriorityQueueType1Node* _tmp53_;
 795         GeePriorityQueueType1Node* _tmp62_;
 796         GeePriorityQueueType1Node* _tmp63_;
 797         self = (GeePriorityQueue*) base;
 798         _tmp0_ = self->priv->_r;
 799         if (_tmp0_ == NULL) {
 800                 result = NULL;
 801                 return result;
 802         }
 803         _tmp1_ = self->priv->_r;
 804         _tmp2_ = ((GeePriorityQueueNode*) _tmp1_)->data;
 805         _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
 806         min = _tmp3_;
 807         _tmp4_ = self->priv->_r;
 808         ((GeePriorityQueueNode*) _tmp4_)->pending_drop = FALSE;
 809         _tmp5_ = self->priv->_stamp;
 810         self->priv->_stamp = _tmp5_ + 1;
 811         _tmp6_ = self->priv->_size;
 812         self->priv->_size = _tmp6_ - 1;
 813         _tmp7_ = self->priv->_r_prime;
 814         if (_tmp7_ == NULL) {
 815                 GeePriorityQueueType1Node* _tmp8_;
 816                 GeePriorityQueueNode* _tmp9_;
 817                 GeePriorityQueueType1Node* _tmp14_;
 818                 GeePriorityQueueNode* _tmp15_;
 819                 GeePriorityQueueNode* _tmp20_;
 820                 GeePriorityQueueType1Node* _tmp21_;
 821                 GeePriorityQueueNode* _tmp24_;
 822                 GeePriorityQueueType1Node* _tmp25_;
 823                 _tmp8_ = self->priv->_r;
 824                 _tmp9_ = ((GeePriorityQueueNode*) _tmp8_)->iter_next;
 825                 if (_tmp9_ != NULL) {
 826                         GeePriorityQueueType1Node* _tmp10_;
 827                         GeePriorityQueueNode* _tmp11_;
 828                         GeePriorityQueueType1Node* _tmp12_;
 829                         GeePriorityQueueNode* _tmp13_;
 830                         _tmp10_ = self->priv->_r;
 831                         _tmp11_ = ((GeePriorityQueueNode*) _tmp10_)->iter_next;
 832                         _tmp12_ = self->priv->_r;
 833                         _tmp13_ = ((GeePriorityQueueNode*) _tmp12_)->iter_prev;
 834                         _tmp11_->iter_prev = _tmp13_;
 835                 }
 836                 _tmp14_ = self->priv->_r;
 837                 _tmp15_ = ((GeePriorityQueueNode*) _tmp14_)->iter_prev;
 838                 if (_tmp15_ != NULL) {
 839                         GeePriorityQueueType1Node* _tmp16_;
 840                         GeePriorityQueueNode* _tmp17_;
 841                         GeePriorityQueueType1Node* _tmp18_;
 842                         GeePriorityQueueNode* _tmp19_;
 843                         _tmp16_ = self->priv->_r;
 844                         _tmp17_ = ((GeePriorityQueueNode*) _tmp16_)->iter_prev;
 845                         _tmp18_ = self->priv->_r;
 846                         _tmp19_ = ((GeePriorityQueueNode*) _tmp18_)->iter_next;
 847                         _tmp17_->iter_next = _tmp19_;
 848                 }
 849                 _tmp20_ = self->priv->_iter_head;
 850                 _tmp21_ = self->priv->_r;
 851                 if (_tmp20_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp21_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
 852                         GeePriorityQueueType1Node* _tmp22_;
 853                         GeePriorityQueueNode* _tmp23_;
 854                         _tmp22_ = self->priv->_r;
 855                         _tmp23_ = ((GeePriorityQueueNode*) _tmp22_)->iter_next;
 856                         self->priv->_iter_head = _tmp23_;
 857                 }
 858                 _tmp24_ = self->priv->_iter_tail;
 859                 _tmp25_ = self->priv->_r;
 860                 if (_tmp24_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
 861                         GeePriorityQueueType1Node* _tmp26_;
 862                         GeePriorityQueueNode* _tmp27_;
 863                         _tmp26_ = self->priv->_r;
 864                         _tmp27_ = ((GeePriorityQueueNode*) _tmp26_)->iter_prev;
 865                         self->priv->_iter_tail = _tmp27_;
 866                 }
 867                 _gee_priority_queue_node_unref0 (self->priv->_r);
 868                 self->priv->_r = NULL;
 869                 _gee_priority_queue_node_unref0 (self->priv->_p);
 870                 self->priv->_p = NULL;
 871                 result = min;
 872                 return result;
 873         }
 874         _tmp28_ = self->priv->_r;
 875         _tmp29_ = self->priv->_r_prime;
 876         _gee_priority_queue_move_data (self, (GeePriorityQueueNode*) _tmp28_, (GeePriorityQueueNode*) _tmp29_);
 877         _tmp30_ = self->priv->_r_prime;
 878         _tmp31_ = ((GeePriorityQueueNode*) _tmp30_)->type1_children_head;
 879         if (_tmp31_ == NULL) {
 880                 GeePriorityQueueType2Node* _tmp32_;
 881                 _tmp32_ = self->priv->_r_prime;
 882                 _gee_priority_queue_remove_type2_node (self, _tmp32_, TRUE);
 883                 _gee_priority_queue_node_unref0 (self->priv->_r_prime);
 884                 self->priv->_r_prime = NULL;
 885                 result = min;
 886                 return result;
 887         }
 888         r_second = NULL;
 889         _tmp33_ = self->priv->_r_prime;
 890         _tmp34_ = ((GeePriorityQueueNode*) _tmp33_)->type1_children_head;
 891         _tmp35_ = _gee_priority_queue_node_ref0 (_tmp34_);
 892         node = _tmp35_;
 893         while (TRUE) {
 894                 GeePriorityQueueType1Node* _tmp36_;
 895                 gboolean _tmp37_ = FALSE;
 896                 GeePriorityQueueType1Node* _tmp38_;
 897                 gboolean _tmp42_;
 898                 GeePriorityQueueType1Node* _tmp45_;
 899                 GeePriorityQueueType1Node* _tmp46_;
 900                 GeePriorityQueueType1Node* _tmp47_;
 901                 _tmp36_ = node;
 902                 if (!(_tmp36_ != NULL)) {
 903                         break;
 904                 }
 905                 _tmp38_ = r_second;
 906                 if (_tmp38_ == NULL) {
 907                         _tmp37_ = TRUE;
 908                 } else {
 909                         GeePriorityQueueType1Node* _tmp39_;
 910                         GeePriorityQueueType1Node* _tmp40_;
 911                         gint _tmp41_ = 0;
 912                         _tmp39_ = node;
 913                         _tmp40_ = r_second;
 914                         _tmp41_ = _gee_priority_queue_compare (self, (GeePriorityQueueNode*) _tmp39_, (GeePriorityQueueNode*) _tmp40_);
 915                         _tmp37_ = _tmp41_ < 0;
 916                 }
 917                 _tmp42_ = _tmp37_;
 918                 if (_tmp42_) {
 919                         GeePriorityQueueType1Node* _tmp43_;
 920                         GeePriorityQueueType1Node* _tmp44_;
 921                         _tmp43_ = node;
 922                         _tmp44_ = _gee_priority_queue_node_ref0 (_tmp43_);
 923                         _gee_priority_queue_node_unref0 (r_second);
 924                         r_second = _tmp44_;
 925                 }
 926                 _tmp45_ = node;
 927                 _tmp46_ = _tmp45_->brothers_next;
 928                 _tmp47_ = _gee_priority_queue_node_ref0 (_tmp46_);
 929                 _gee_priority_queue_node_unref0 (node);
 930                 node = _tmp47_;
 931         }
 932         _tmp48_ = self->priv->_r_prime;
 933         _tmp49_ = r_second;
 934         _gee_priority_queue_move_data (self, (GeePriorityQueueNode*) _tmp48_, (GeePriorityQueueNode*) _tmp49_);
 935         _tmp50_ = r_second;
 936         _gee_priority_queue_remove_type1_node (self, _tmp50_, TRUE);
 937         _tmp51_ = r_second;
 938         _tmp52_ = ((GeePriorityQueueNode*) _tmp51_)->type1_children_head;
 939         _tmp53_ = _gee_priority_queue_node_ref0 (_tmp52_);
 940         _gee_priority_queue_node_unref0 (node);
 941         node = _tmp53_;
 942         while (TRUE) {
 943                 GeePriorityQueueType1Node* _tmp54_;
 944                 GeePriorityQueueType1Node* _tmp55_;
 945                 GeePriorityQueueType1Node* _tmp56_;
 946                 GeePriorityQueueType1Node* _tmp57_;
 947                 GeePriorityQueueType1Node* next;
 948                 GeePriorityQueueType1Node* _tmp58_;
 949                 GeePriorityQueueType1Node* _tmp59_;
 950                 GeePriorityQueueType1Node* _tmp60_;
 951                 GeePriorityQueueType1Node* _tmp61_;
 952                 _tmp54_ = node;
 953                 if (!(_tmp54_ != NULL)) {
 954                         break;
 955                 }
 956                 _tmp55_ = node;
 957                 _tmp56_ = _tmp55_->brothers_next;
 958                 _tmp57_ = _gee_priority_queue_node_ref0 (_tmp56_);
 959                 next = _tmp57_;
 960                 _tmp58_ = node;
 961                 _gee_priority_queue_remove_type1_node (self, _tmp58_, FALSE);
 962                 _tmp59_ = node;
 963                 _gee_priority_queue_add_in_r_prime (self, _tmp59_);
 964                 _tmp60_ = next;
 965                 _tmp61_ = _gee_priority_queue_node_ref0 (_tmp60_);
 966                 _gee_priority_queue_node_unref0 (node);
 967                 node = _tmp61_;
 968                 _gee_priority_queue_node_unref0 (next);
 969         }
 970         _tmp62_ = self->priv->_p;
 971         _tmp63_ = self->priv->_p;
 972         _gee_priority_queue_adjust (self, _tmp62_, _tmp63_);
 973         while (TRUE) {
 974                 gboolean _tmp64_ = FALSE;
 975                 _tmp64_ = _gee_priority_queue_check_linkable (self);
 976                 if (!_tmp64_) {
 977                         break;
 978                 }
 979         }
 980         result = min;
 981         _gee_priority_queue_node_unref0 (node);
 982         _gee_priority_queue_node_unref0 (r_second);
 983         return result;
 984 }
 985
 986
 987 /**
 988  * {@inheritDoc}
 989  */
 990 gint gee_priority_queue_drain (GeePriorityQueue* self, GeeCollection* recipient, gint amount) {
 991         gint result = 0;
 992         gint _tmp0_;
 993         gint _tmp11_;
 994         g_return_val_if_fail (self != NULL, 0);
 995         g_return_val_if_fail (recipient != NULL, 0);
 996         _tmp0_ = amount;
 997         if (_tmp0_ == (-1)) {
 998                 gint _tmp1_;
 999                 _tmp1_ = self->priv->_size;
1000                 amount = _tmp1_;
1001         }
1002         {
1003                 gint i;
1004                 i = 0;
1005                 {
1006                         gboolean _tmp2_;
1007                         _tmp2_ = TRUE;
1008                         while (TRUE) {
1009                                 gboolean _tmp3_;
1010                                 gint _tmp5_;
1011                                 gint _tmp6_;
1012                                 gint _tmp7_;
1013                                 GeeCollection* _tmp8_;
1014                                 gpointer _tmp9_ = NULL;
1015                                 gpointer _tmp10_;
1016                                 _tmp3_ = _tmp2_;
1017                                 if (!_tmp3_) {
1018                                         gint _tmp4_;
1019                                         _tmp4_ = i;
1020                                         i = _tmp4_ + 1;
1021                                 }
1022                                 _tmp2_ = FALSE;
1023                                 _tmp5_ = i;
1024                                 _tmp6_ = amount;
1025                                 if (!(_tmp5_ < _tmp6_)) {
1026                                         break;
1027                                 }
1028                                 _tmp7_ = self->priv->_size;
1029                                 if (_tmp7_ == 0) {
1030                                         result = i;
1031                                         return result;
1032                                 }
1033                                 _tmp8_ = recipient;
1034                                 _tmp9_ = gee_abstract_queue_poll ((GeeAbstractQueue*) self);
1035                                 _tmp10_ = _tmp9_;
1036                                 gee_collection_add (_tmp8_, _tmp10_);
1037                                 ((_tmp10_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp10_ = (self->priv->g_destroy_func (_tmp10_), NULL));
1038                         }
1039                 }
1040         }
1041         _tmp11_ = amount;
1042         result = _tmp11_;
1043         return result;
1044 }
1045
1046
1047 /**
1048  * {@inheritDoc}
1049  */
1050 static gboolean gee_priority_queue_real_contains (GeeAbstractCollection* base, gconstpointer item) {
1051         GeePriorityQueue * self;
1052         gboolean result = FALSE;
1053         self = (GeePriorityQueue*) base;
1054         {
1055                 GeeIterator* _tmp0_ = NULL;
1056                 GeeIterator* _an_item_it;
1057                 _tmp0_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) self);
1058                 _an_item_it = _tmp0_;
1059                 while (TRUE) {
1060                         GeeIterator* _tmp1_;
1061                         gboolean _tmp2_ = FALSE;
1062                         GeeIterator* _tmp3_;
1063                         gpointer _tmp4_ = NULL;
1064                         gpointer an_item;
1065                         GCompareDataFunc _tmp5_;
1066                         void* _tmp5__target;
1067                         GCompareDataFunc _tmp6_;
1068                         void* _tmp6__target;
1069                         gconstpointer _tmp7_;
1070                         gconstpointer _tmp8_;
1071                         gint _tmp9_ = 0;
1072                         _tmp1_ = _an_item_it;
1073                         _tmp2_ = gee_iterator_next (_tmp1_);
1074                         if (!_tmp2_) {
1075                                 break;
1076                         }
1077                         _tmp3_ = _an_item_it;
1078                         _tmp4_ = gee_iterator_get (_tmp3_);
1079                         an_item = _tmp4_;
1080                         _tmp5_ = gee_priority_queue_get_compare_func (self, &_tmp5__target);
1081                         _tmp6_ = _tmp5_;
1082                         _tmp6__target = _tmp5__target;
1083                         _tmp7_ = item;
1084                         _tmp8_ = an_item;
1085                         _tmp9_ = _tmp6_ (_tmp7_, _tmp8_, _tmp6__target);
1086                         if (_tmp9_ == 0) {
1087                                 result = TRUE;
1088                                 ((an_item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (an_item = (self->priv->g_destroy_func (an_item), NULL));
1089                                 _g_object_unref0 (_an_item_it);
1090                                 return result;
1091                         }
1092                         ((an_item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (an_item = (self->priv->g_destroy_func (an_item), NULL));
1093                 }
1094                 _g_object_unref0 (_an_item_it);
1095         }
1096         result = FALSE;
1097         return result;
1098 }
1099
1100
1101 /**
1102  * {@inheritDoc}
1103  */
1104 static gboolean gee_priority_queue_real_add (GeeAbstractCollection* base, gconstpointer item) {
1105         GeePriorityQueue * self;
1106         gboolean result = FALSE;
1107         gconstpointer _tmp0_;
1108         gboolean _tmp1_ = FALSE;
1109         self = (GeePriorityQueue*) base;
1110         _tmp0_ = item;
1111         _tmp1_ = gee_priority_queue_offer (self, _tmp0_);
1112         result = _tmp1_;
1113         return result;
1114 }
1115
1116
1117 /**
1118  * {@inheritDoc}
1119  */
1120 static gboolean gee_priority_queue_real_remove (GeeAbstractCollection* base, gconstpointer item) {
1121         GeePriorityQueue * self;
1122         gboolean result = FALSE;
1123         GeePriorityQueueIterator* _tmp0_;
1124         GeePriorityQueueIterator* iterator;
1125         self = (GeePriorityQueue*) base;
1126         _tmp0_ = gee_priority_queue_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
1127         iterator = _tmp0_;
1128         while (TRUE) {
1129                 GeePriorityQueueIterator* _tmp1_;
1130                 gboolean _tmp2_ = FALSE;
1131                 GeePriorityQueueIterator* _tmp3_;
1132                 gpointer _tmp4_ = NULL;
1133                 gpointer an_item;
1134                 GCompareDataFunc _tmp5_;
1135                 void* _tmp5__target;
1136                 GCompareDataFunc _tmp6_;
1137                 void* _tmp6__target;
1138                 gconstpointer _tmp7_;
1139                 gconstpointer _tmp8_;
1140                 gint _tmp9_ = 0;
1141                 _tmp1_ = iterator;
1142                 _tmp2_ = gee_iterator_next ((GeeIterator*) _tmp1_);
1143                 if (!_tmp2_) {
1144                         break;
1145                 }
1146                 _tmp3_ = iterator;
1147                 _tmp4_ = gee_iterator_get ((GeeIterator*) _tmp3_);
1148                 an_item = _tmp4_;
1149                 _tmp5_ = gee_priority_queue_get_compare_func (self, &_tmp5__target);
1150                 _tmp6_ = _tmp5_;
1151                 _tmp6__target = _tmp5__target;
1152                 _tmp7_ = item;
1153                 _tmp8_ = an_item;
1154                 _tmp9_ = _tmp6_ (_tmp7_, _tmp8_, _tmp6__target);
1155                 if (_tmp9_ == 0) {
1156                         GeePriorityQueueIterator* _tmp10_;
1157                         _tmp10_ = iterator;
1158                         gee_iterator_remove ((GeeIterator*) _tmp10_);
1159                         result = TRUE;
1160                         ((an_item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (an_item = (self->priv->g_destroy_func (an_item), NULL));
1161                         _g_object_unref0 (iterator);
1162                         return result;
1163                 }
1164                 ((an_item == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (an_item = (self->priv->g_destroy_func (an_item), NULL));
1165         }
1166         result = FALSE;
1167         _g_object_unref0 (iterator);
1168         return result;
1169 }
1170
1171
1172 /**
1173  * {@inheritDoc}
1174  */
1175 static void gee_priority_queue_real_clear (GeeAbstractCollection* base) {
1176         GeePriorityQueue * self;
1177         GeePriorityQueueType1Node** _tmp0_ = NULL;
1178         gboolean* _tmp1_ = NULL;
1179         self = (GeePriorityQueue*) base;
1180         self->priv->_size = 0;
1181         _gee_priority_queue_node_unref0 (self->priv->_r);
1182         self->priv->_r = NULL;
1183         _gee_priority_queue_node_unref0 (self->priv->_r_prime);
1184         self->priv->_r_prime = NULL;
1185         _gee_priority_queue_node_unref0 (self->priv->_lm_head);
1186         self->priv->_lm_head = NULL;
1187         _gee_priority_queue_node_unref0 (self->priv->_lm_tail);
1188         self->priv->_lm_tail = NULL;
1189         _gee_priority_queue_node_unref0 (self->priv->_p);
1190         self->priv->_p = NULL;
1191         _tmp0_ = g_new0 (GeePriorityQueueType1Node*, 0 + 1);
1192         self->priv->_a = (_vala_array_free (self->priv->_a, self->priv->_a_length1, (GDestroyNotify) gee_priority_queue_node_unref), NULL);
1193         self->priv->_a = _tmp0_;
1194         self->priv->_a_length1 = 0;
1195         self->priv->__a_size_ = self->priv->_a_length1;
1196         _gee_priority_queue_node_pair_free0 (self->priv->_lp_head);
1197         self->priv->_lp_head = NULL;
1198         self->priv->_lp_tail = NULL;
1199         _tmp1_ = g_new0 (gboolean, 0);
1200         self->priv->_b = (g_free (self->priv->_b), NULL);
1201         self->priv->_b = _tmp1_;
1202         self->priv->_b_length1 = 0;
1203         self->priv->__b_size_ = self->priv->_b_length1;
1204         _gee_priority_queue_node_unref0 (self->priv->_ll_head);
1205         self->priv->_ll_head = NULL;
1206         _gee_priority_queue_node_unref0 (self->priv->_ll_tail);
1207         self->priv->_ll_tail = NULL;
1208         self->priv->_iter_head = NULL;
1209         self->priv->_iter_tail = NULL;
1210 }
1211
1212
1213 /**
1214  * {@inheritDoc}
1215  */
1216 static GeeIterator* gee_priority_queue_real_iterator (GeeAbstractCollection* base) {
1217         GeePriorityQueue * self;
1218         GeeIterator* result = NULL;
1219         GeePriorityQueueIterator* _tmp0_;
1220         self = (GeePriorityQueue*) base;
1221         _tmp0_ = gee_priority_queue_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
1222         result = (GeeIterator*) _tmp0_;
1223         return result;
1224 }
1225
1226
1227 static inline gint _gee_priority_queue_compare (GeePriorityQueue* self, GeePriorityQueueNode* node1, GeePriorityQueueNode* node2) {
1228         gint result = 0;
1229         GeePriorityQueueNode* _tmp0_;
1230         gboolean _tmp1_;
1231         g_return_val_if_fail (self != NULL, 0);
1232         g_return_val_if_fail (node1 != NULL, 0);
1233         g_return_val_if_fail (node2 != NULL, 0);
1234         _tmp0_ = node1;
1235         _tmp1_ = _tmp0_->pending_drop;
1236         if (_tmp1_) {
1237                 result = -1;
1238                 return result;
1239         } else {
1240                 GeePriorityQueueNode* _tmp2_;
1241                 gboolean _tmp3_;
1242                 _tmp2_ = node2;
1243                 _tmp3_ = _tmp2_->pending_drop;
1244                 if (_tmp3_) {
1245                         result = 1;
1246                         return result;
1247                 } else {
1248                         GCompareDataFunc _tmp4_;
1249                         void* _tmp4__target;
1250                         GCompareDataFunc _tmp5_;
1251                         void* _tmp5__target;
1252                         GeePriorityQueueNode* _tmp6_;
1253                         gconstpointer _tmp7_;
1254                         GeePriorityQueueNode* _tmp8_;
1255                         gconstpointer _tmp9_;
1256                         gint _tmp10_ = 0;
1257                         _tmp4_ = gee_priority_queue_get_compare_func (self, &_tmp4__target);
1258                         _tmp5_ = _tmp4_;
1259                         _tmp5__target = _tmp4__target;
1260                         _tmp6_ = node1;
1261                         _tmp7_ = _tmp6_->data;
1262                         _tmp8_ = node2;
1263                         _tmp9_ = _tmp8_->data;
1264                         _tmp10_ = _tmp5_ (_tmp7_, _tmp9_, _tmp5__target);
1265                         result = _tmp10_;
1266                         return result;
1267                 }
1268         }
1269 }
1270
1271
1272 static inline void _gee_priority_queue_swap_data (GeePriorityQueue* self, GeePriorityQueueNode* node1, GeePriorityQueueNode* node2) {
1273         GeePriorityQueueNode* _tmp0_;
1274         gpointer _tmp1_;
1275         gpointer temp_data;
1276         GeePriorityQueueNode* _tmp2_;
1277         gboolean _tmp3_;
1278         gboolean temp_pending_drop;
1279         GeePriorityQueueNode* _tmp4_;
1280         GeePriorityQueueNode* _tmp5_;
1281         gpointer _tmp6_;
1282         GeePriorityQueueNode* _tmp7_;
1283         GeePriorityQueueNode* _tmp8_;
1284         gboolean _tmp9_;
1285         GeePriorityQueueNode* _tmp10_;
1286         gpointer _tmp11_;
1287         GeePriorityQueueNode* _tmp12_;
1288         gboolean _tmp13_;
1289         GeePriorityQueueNode* _tmp14_;
1290         GeePriorityQueueNode* _tmp15_;
1291         GeePriorityQueueNode* _tmp16_;
1292         GeePriorityQueueNode* _tmp58_;
1293         GeePriorityQueueNode* _tmp59_;
1294         GeePriorityQueueNode* _tmp64_;
1295         GeePriorityQueueNode* _tmp65_;
1296         GeePriorityQueueNode* _tmp70_;
1297         GeePriorityQueueNode* _tmp71_;
1298         GeePriorityQueueNode* _tmp75_;
1299         GeePriorityQueueNode* _tmp76_;
1300         GeePriorityQueueNode* _tmp80_;
1301         GeePriorityQueueNode* _tmp81_;
1302         GeePriorityQueueNode* _tmp85_;
1303         GeePriorityQueueNode* _tmp86_;
1304         g_return_if_fail (self != NULL);
1305         g_return_if_fail (node1 != NULL);
1306         g_return_if_fail (node2 != NULL);
1307         _tmp0_ = node1;
1308         _tmp1_ = _tmp0_->data;
1309         _tmp0_->data = NULL;
1310         temp_data = _tmp1_;
1311         _tmp2_ = node1;
1312         _tmp3_ = _tmp2_->pending_drop;
1313         temp_pending_drop = _tmp3_;
1314         _tmp4_ = node1;
1315         _tmp5_ = node2;
1316         _tmp6_ = _tmp5_->data;
1317         _tmp5_->data = NULL;
1318         ((_tmp4_->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp4_->data = (self->priv->g_destroy_func (_tmp4_->data), NULL));
1319         _tmp4_->data = _tmp6_;
1320         _tmp7_ = node1;
1321         _tmp8_ = node2;
1322         _tmp9_ = _tmp8_->pending_drop;
1323         _tmp7_->pending_drop = _tmp9_;
1324         _tmp10_ = node2;
1325         _tmp11_ = temp_data;
1326         temp_data = NULL;
1327         ((_tmp10_->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp10_->data = (self->priv->g_destroy_func (_tmp10_->data), NULL));
1328         _tmp10_->data = _tmp11_;
1329         _tmp12_ = node2;
1330         _tmp13_ = temp_pending_drop;
1331         _tmp12_->pending_drop = _tmp13_;
1332         _tmp14_ = node1;
1333         _tmp15_ = _tmp14_->iter_next;
1334         _tmp16_ = node2;
1335         if (_tmp15_ == _tmp16_) {
1336                 GeePriorityQueueNode* _tmp17_;
1337                 GeePriorityQueueNode* _tmp18_;
1338                 GeePriorityQueueNode* temp_iter_prev;
1339                 GeePriorityQueueNode* _tmp19_;
1340                 GeePriorityQueueNode* _tmp20_;
1341                 GeePriorityQueueNode* temp_iter_next;
1342                 GeePriorityQueueNode* _tmp21_;
1343                 GeePriorityQueueNode* _tmp22_;
1344                 GeePriorityQueueNode* _tmp23_;
1345                 GeePriorityQueueNode* _tmp24_;
1346                 GeePriorityQueueNode* _tmp25_;
1347                 GeePriorityQueueNode* _tmp26_;
1348                 GeePriorityQueueNode* _tmp27_;
1349                 GeePriorityQueueNode* _tmp28_;
1350                 _tmp17_ = node1;
1351                 _tmp18_ = _tmp17_->iter_prev;
1352                 temp_iter_prev = _tmp18_;
1353                 _tmp19_ = node2;
1354                 _tmp20_ = _tmp19_->iter_next;
1355                 temp_iter_next = _tmp20_;
1356                 _tmp21_ = node1;
1357                 _tmp22_ = node2;
1358                 _tmp21_->iter_prev = _tmp22_;
1359                 _tmp23_ = node1;
1360                 _tmp24_ = temp_iter_next;
1361                 _tmp23_->iter_next = _tmp24_;
1362                 _tmp25_ = node2;
1363                 _tmp26_ = temp_iter_prev;
1364                 _tmp25_->iter_prev = _tmp26_;
1365                 _tmp27_ = node2;
1366                 _tmp28_ = node1;
1367                 _tmp27_->iter_next = _tmp28_;
1368         } else {
1369                 GeePriorityQueueNode* _tmp29_;
1370                 GeePriorityQueueNode* _tmp30_;
1371                 GeePriorityQueueNode* _tmp31_;
1372                 _tmp29_ = node1;
1373                 _tmp30_ = _tmp29_->iter_prev;
1374                 _tmp31_ = node2;
1375                 if (_tmp30_ == _tmp31_) {
1376                         GeePriorityQueueNode* _tmp32_;
1377                         GeePriorityQueueNode* _tmp33_;
1378                         GeePriorityQueueNode* temp_iter_prev;
1379                         GeePriorityQueueNode* _tmp34_;
1380                         GeePriorityQueueNode* _tmp35_;
1381                         GeePriorityQueueNode* temp_iter_next;
1382                         GeePriorityQueueNode* _tmp36_;
1383                         GeePriorityQueueNode* _tmp37_;
1384                         GeePriorityQueueNode* _tmp38_;
1385                         GeePriorityQueueNode* _tmp39_;
1386                         GeePriorityQueueNode* _tmp40_;
1387                         GeePriorityQueueNode* _tmp41_;
1388                         GeePriorityQueueNode* _tmp42_;
1389                         GeePriorityQueueNode* _tmp43_;
1390                         _tmp32_ = node2;
1391                         _tmp33_ = _tmp32_->iter_prev;
1392                         temp_iter_prev = _tmp33_;
1393                         _tmp34_ = node1;
1394                         _tmp35_ = _tmp34_->iter_next;
1395                         temp_iter_next = _tmp35_;
1396                         _tmp36_ = node1;
1397                         _tmp37_ = temp_iter_prev;
1398                         _tmp36_->iter_prev = _tmp37_;
1399                         _tmp38_ = node1;
1400                         _tmp39_ = node2;
1401                         _tmp38_->iter_next = _tmp39_;
1402                         _tmp40_ = node2;
1403                         _tmp41_ = node1;
1404                         _tmp40_->iter_prev = _tmp41_;
1405                         _tmp42_ = node2;
1406                         _tmp43_ = temp_iter_next;
1407                         _tmp42_->iter_next = _tmp43_;
1408                 } else {
1409                         GeePriorityQueueNode* _tmp44_;
1410                         GeePriorityQueueNode* _tmp45_;
1411                         GeePriorityQueueNode* temp_iter_prev;
1412                         GeePriorityQueueNode* _tmp46_;
1413                         GeePriorityQueueNode* _tmp47_;
1414                         GeePriorityQueueNode* temp_iter_next;
1415                         GeePriorityQueueNode* _tmp48_;
1416                         GeePriorityQueueNode* _tmp49_;
1417                         GeePriorityQueueNode* _tmp50_;
1418                         GeePriorityQueueNode* _tmp51_;
1419                         GeePriorityQueueNode* _tmp52_;
1420                         GeePriorityQueueNode* _tmp53_;
1421                         GeePriorityQueueNode* _tmp54_;
1422                         GeePriorityQueueNode* _tmp55_;
1423                         GeePriorityQueueNode* _tmp56_;
1424                         GeePriorityQueueNode* _tmp57_;
1425                         _tmp44_ = node1;
1426                         _tmp45_ = _tmp44_->iter_prev;
1427                         temp_iter_prev = _tmp45_;
1428                         _tmp46_ = node1;
1429                         _tmp47_ = _tmp46_->iter_next;
1430                         temp_iter_next = _tmp47_;
1431                         _tmp48_ = node1;
1432                         _tmp49_ = node2;
1433                         _tmp50_ = _tmp49_->iter_prev;
1434                         _tmp48_->iter_prev = _tmp50_;
1435                         _tmp51_ = node1;
1436                         _tmp52_ = node2;
1437                         _tmp53_ = _tmp52_->iter_next;
1438                         _tmp51_->iter_next = _tmp53_;
1439                         _tmp54_ = node2;
1440                         _tmp55_ = temp_iter_prev;
1441                         _tmp54_->iter_prev = _tmp55_;
1442                         _tmp56_ = node2;
1443                         _tmp57_ = temp_iter_next;
1444                         _tmp56_->iter_next = _tmp57_;
1445                 }
1446         }
1447         _tmp58_ = node2;
1448         _tmp59_ = self->priv->_iter_head;
1449         if (_tmp58_ == _tmp59_) {
1450                 GeePriorityQueueNode* _tmp60_;
1451                 _tmp60_ = node1;
1452                 self->priv->_iter_head = _tmp60_;
1453         } else {
1454                 GeePriorityQueueNode* _tmp61_;
1455                 GeePriorityQueueNode* _tmp62_;
1456                 _tmp61_ = node1;
1457                 _tmp62_ = self->priv->_iter_head;
1458                 if (_tmp61_ == _tmp62_) {
1459                         GeePriorityQueueNode* _tmp63_;
1460                         _tmp63_ = node2;
1461                         self->priv->_iter_head = _tmp63_;
1462                 }
1463         }
1464         _tmp64_ = node2;
1465         _tmp65_ = self->priv->_iter_tail;
1466         if (_tmp64_ == _tmp65_) {
1467                 GeePriorityQueueNode* _tmp66_;
1468                 _tmp66_ = node1;
1469                 self->priv->_iter_tail = _tmp66_;
1470         } else {
1471                 GeePriorityQueueNode* _tmp67_;
1472                 GeePriorityQueueNode* _tmp68_;
1473                 _tmp67_ = node1;
1474                 _tmp68_ = self->priv->_iter_tail;
1475                 if (_tmp67_ == _tmp68_) {
1476                         GeePriorityQueueNode* _tmp69_;
1477                         _tmp69_ = node2;
1478                         self->priv->_iter_tail = _tmp69_;
1479                 }
1480         }
1481         _tmp70_ = node1;
1482         _tmp71_ = _tmp70_->iter_prev;
1483         if (_tmp71_ != NULL) {
1484                 GeePriorityQueueNode* _tmp72_;
1485                 GeePriorityQueueNode* _tmp73_;
1486                 GeePriorityQueueNode* _tmp74_;
1487                 _tmp72_ = node1;
1488                 _tmp73_ = _tmp72_->iter_prev;
1489                 _tmp74_ = node1;
1490                 _tmp73_->iter_next = _tmp74_;
1491         }
1492         _tmp75_ = node1;
1493         _tmp76_ = _tmp75_->iter_next;
1494         if (_tmp76_ != NULL) {
1495                 GeePriorityQueueNode* _tmp77_;
1496                 GeePriorityQueueNode* _tmp78_;
1497                 GeePriorityQueueNode* _tmp79_;
1498                 _tmp77_ = node1;
1499                 _tmp78_ = _tmp77_->iter_next;
1500                 _tmp79_ = node1;
1501                 _tmp78_->iter_prev = _tmp79_;
1502         }
1503         _tmp80_ = node2;
1504         _tmp81_ = _tmp80_->iter_prev;
1505         if (_tmp81_ != NULL) {
1506                 GeePriorityQueueNode* _tmp82_;
1507                 GeePriorityQueueNode* _tmp83_;
1508                 GeePriorityQueueNode* _tmp84_;
1509                 _tmp82_ = node2;
1510                 _tmp83_ = _tmp82_->iter_prev;
1511                 _tmp84_ = node2;
1512                 _tmp83_->iter_next = _tmp84_;
1513         }
1514         _tmp85_ = node2;
1515         _tmp86_ = _tmp85_->iter_next;
1516         if (_tmp86_ != NULL) {
1517                 GeePriorityQueueNode* _tmp87_;
1518                 GeePriorityQueueNode* _tmp88_;
1519                 GeePriorityQueueNode* _tmp89_;
1520                 _tmp87_ = node2;
1521                 _tmp88_ = _tmp87_->iter_next;
1522                 _tmp89_ = node2;
1523                 _tmp88_->iter_prev = _tmp89_;
1524         }
1525         ((temp_data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (temp_data = (self->priv->g_destroy_func (temp_data), NULL));
1526 }
1527
1528
1529 static inline void _gee_priority_queue_move_data (GeePriorityQueue* self, GeePriorityQueueNode* target, GeePriorityQueueNode* source) {
1530         GeePriorityQueueNode* _tmp0_;
1531         GeePriorityQueueNode* _tmp1_;
1532         GeePriorityQueueNode* _tmp10_;
1533         GeePriorityQueueNode* _tmp11_;
1534         GeePriorityQueueNode* _tmp20_;
1535         GeePriorityQueueNode* _tmp21_;
1536         gconstpointer _tmp22_;
1537         gpointer _tmp23_;
1538         GeePriorityQueueNode* _tmp24_;
1539         GeePriorityQueueNode* _tmp25_;
1540         gboolean _tmp26_;
1541         GeePriorityQueueNode* _tmp27_;
1542         GeePriorityQueueNode* _tmp28_;
1543         GeePriorityQueueNode* _tmp29_;
1544         GeePriorityQueueNode* _tmp30_;
1545         GeePriorityQueueNode* _tmp31_;
1546         GeePriorityQueueNode* _tmp32_;
1547         GeePriorityQueueNode* _tmp33_;
1548         GeePriorityQueueNode* _tmp34_;
1549         GeePriorityQueueNode* _tmp35_;
1550         GeePriorityQueueNode* _tmp36_;
1551         GeePriorityQueueNode* _tmp43_;
1552         GeePriorityQueueNode* _tmp44_;
1553         g_return_if_fail (self != NULL);
1554         g_return_if_fail (target != NULL);
1555         g_return_if_fail (source != NULL);
1556         _tmp0_ = target;
1557         _tmp1_ = _tmp0_->iter_next;
1558         if (_tmp1_ != NULL) {
1559                 GeePriorityQueueNode* _tmp2_;
1560                 GeePriorityQueueNode* _tmp3_;
1561                 GeePriorityQueueNode* _tmp4_;
1562                 GeePriorityQueueNode* _tmp5_;
1563                 _tmp2_ = target;
1564                 _tmp3_ = _tmp2_->iter_next;
1565                 _tmp4_ = target;
1566                 _tmp5_ = _tmp4_->iter_prev;
1567                 _tmp3_->iter_prev = _tmp5_;
1568         } else {
1569                 GeePriorityQueueNode* _tmp6_;
1570                 GeePriorityQueueNode* _tmp7_;
1571                 _tmp6_ = self->priv->_iter_tail;
1572                 _tmp7_ = target;
1573                 if (_tmp6_ == _tmp7_) {
1574                         GeePriorityQueueNode* _tmp8_;
1575                         GeePriorityQueueNode* _tmp9_;
1576                         _tmp8_ = target;
1577                         _tmp9_ = _tmp8_->iter_prev;
1578                         self->priv->_iter_tail = _tmp9_;
1579                 }
1580         }
1581         _tmp10_ = target;
1582         _tmp11_ = _tmp10_->iter_prev;
1583         if (_tmp11_ != NULL) {
1584                 GeePriorityQueueNode* _tmp12_;
1585                 GeePriorityQueueNode* _tmp13_;
1586                 GeePriorityQueueNode* _tmp14_;
1587                 GeePriorityQueueNode* _tmp15_;
1588                 _tmp12_ = target;
1589                 _tmp13_ = _tmp12_->iter_prev;
1590                 _tmp14_ = target;
1591                 _tmp15_ = _tmp14_->iter_next;
1592                 _tmp13_->iter_next = _tmp15_;
1593         } else {
1594                 GeePriorityQueueNode* _tmp16_;
1595                 GeePriorityQueueNode* _tmp17_;
1596                 _tmp16_ = self->priv->_iter_head;
1597                 _tmp17_ = target;
1598                 if (_tmp16_ == _tmp17_) {
1599                         GeePriorityQueueNode* _tmp18_;
1600                         GeePriorityQueueNode* _tmp19_;
1601                         _tmp18_ = target;
1602                         _tmp19_ = _tmp18_->iter_next;
1603                         self->priv->_iter_head = _tmp19_;
1604                 }
1605         }
1606         _tmp20_ = target;
1607         _tmp21_ = source;
1608         _tmp22_ = _tmp21_->data;
1609         _tmp23_ = ((_tmp22_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp22_) : ((gpointer) _tmp22_);
1610         ((_tmp20_->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp20_->data = (self->priv->g_destroy_func (_tmp20_->data), NULL));
1611         _tmp20_->data = _tmp23_;
1612         _tmp24_ = target;
1613         _tmp25_ = source;
1614         _tmp26_ = _tmp25_->pending_drop;
1615         _tmp24_->pending_drop = _tmp26_;
1616         _tmp27_ = target;
1617         _tmp28_ = source;
1618         _tmp29_ = _tmp28_->iter_next;
1619         _tmp27_->iter_next = _tmp29_;
1620         _tmp30_ = target;
1621         _tmp31_ = source;
1622         _tmp32_ = _tmp31_->iter_prev;
1623         _tmp30_->iter_prev = _tmp32_;
1624         _tmp33_ = source;
1625         _tmp33_->iter_next = NULL;
1626         _tmp34_ = source;
1627         _tmp34_->iter_prev = NULL;
1628         _tmp35_ = target;
1629         _tmp36_ = _tmp35_->iter_next;
1630         if (_tmp36_ != NULL) {
1631                 GeePriorityQueueNode* _tmp37_;
1632                 GeePriorityQueueNode* _tmp38_;
1633                 GeePriorityQueueNode* _tmp39_;
1634                 _tmp37_ = target;
1635                 _tmp38_ = _tmp37_->iter_next;
1636                 _tmp39_ = target;
1637                 _tmp38_->iter_prev = _tmp39_;
1638         } else {
1639                 GeePriorityQueueNode* _tmp40_;
1640                 GeePriorityQueueNode* _tmp41_;
1641                 _tmp40_ = self->priv->_iter_tail;
1642                 _tmp41_ = source;
1643                 if (_tmp40_ == _tmp41_) {
1644                         GeePriorityQueueNode* _tmp42_;
1645                         _tmp42_ = target;
1646                         self->priv->_iter_tail = _tmp42_;
1647                 }
1648         }
1649         _tmp43_ = target;
1650         _tmp44_ = _tmp43_->iter_prev;
1651         if (_tmp44_ != NULL) {
1652                 GeePriorityQueueNode* _tmp45_;
1653                 GeePriorityQueueNode* _tmp46_;
1654                 GeePriorityQueueNode* _tmp47_;
1655                 _tmp45_ = target;
1656                 _tmp46_ = _tmp45_->iter_prev;
1657                 _tmp47_ = target;
1658                 _tmp46_->iter_next = _tmp47_;
1659         } else {
1660                 GeePriorityQueueNode* _tmp48_;
1661                 GeePriorityQueueNode* _tmp49_;
1662                 _tmp48_ = self->priv->_iter_head;
1663                 _tmp49_ = source;
1664                 if (_tmp48_ == _tmp49_) {
1665                         GeePriorityQueueNode* _tmp50_;
1666                         _tmp50_ = target;
1667                         self->priv->_iter_head = _tmp50_;
1668                 }
1669         }
1670 }
1671
1672
1673 static void _gee_priority_queue_link (GeePriorityQueue* self, GeePriorityQueueType1Node* ri, GeePriorityQueueType1Node* rj) {
1674         GeePriorityQueueType1Node* _tmp0_;
1675         gint _tmp1_ = 0;
1676         GeePriorityQueueType1Node* _tmp2_;
1677         gint _tmp3_ = 0;
1678         GeePriorityQueueType1Node* _tmp4_;
1679         GeePriorityQueueType1Node* _tmp5_;
1680         GeePriorityQueueType1Node* _tmp6_;
1681         GeePriorityQueueType1Node* _tmp7_;
1682         gint _tmp8_ = 0;
1683         GeePriorityQueueType1Node* _tmp15_;
1684         GeePriorityQueueType1Node* _tmp16_;
1685         GeePriorityQueueType1Node* _tmp17_;
1686         g_return_if_fail (self != NULL);
1687         g_return_if_fail (ri != NULL);
1688         g_return_if_fail (rj != NULL);
1689         _tmp0_ = ri;
1690         _tmp1_ = gee_priority_queue_node_degree ((GeePriorityQueueNode*) _tmp0_);
1691         _tmp2_ = rj;
1692         _tmp3_ = gee_priority_queue_node_degree ((GeePriorityQueueNode*) _tmp2_);
1693         _vala_assert (_tmp1_ == _tmp3_, "ri.degree () == rj.degree ()");
1694         _tmp4_ = ri;
1695         _gee_priority_queue_remove_type1_node (self, _tmp4_, FALSE);
1696         _tmp5_ = rj;
1697         _gee_priority_queue_remove_type1_node (self, _tmp5_, FALSE);
1698         _tmp6_ = ri;
1699         _tmp7_ = rj;
1700         _tmp8_ = _gee_priority_queue_compare (self, (GeePriorityQueueNode*) _tmp6_, (GeePriorityQueueNode*) _tmp7_);
1701         if (_tmp8_ > 0) {
1702                 GeePriorityQueueType1Node* _tmp9_;
1703                 GeePriorityQueueType1Node* _tmp10_;
1704                 GeePriorityQueueType1Node* temp;
1705                 GeePriorityQueueType1Node* _tmp11_;
1706                 GeePriorityQueueType1Node* _tmp12_;
1707                 GeePriorityQueueType1Node* _tmp13_;
1708                 GeePriorityQueueType1Node* _tmp14_;
1709                 _tmp9_ = ri;
1710                 _tmp10_ = _gee_priority_queue_node_ref0 (_tmp9_);
1711                 temp = _tmp10_;
1712                 _tmp11_ = rj;
1713                 _tmp12_ = _gee_priority_queue_node_ref0 (_tmp11_);
1714                 _gee_priority_queue_node_unref0 (ri);
1715                 ri = _tmp12_;
1716                 _tmp13_ = temp;
1717                 _tmp14_ = _gee_priority_queue_node_ref0 (_tmp13_);
1718                 _gee_priority_queue_node_unref0 (rj);
1719                 rj = _tmp14_;
1720                 _gee_priority_queue_node_unref0 (temp);
1721         }
1722         _tmp15_ = rj;
1723         _tmp16_ = ri;
1724         _gee_priority_queue_add_to (self, _tmp15_, _tmp16_);
1725         _tmp17_ = ri;
1726         _gee_priority_queue_add_in_r_prime (self, _tmp17_);
1727         _gee_priority_queue_node_unref0 (ri);
1728         _gee_priority_queue_node_unref0 (rj);
1729 }
1730
1731
1732 static void _gee_priority_queue_add (GeePriorityQueue* self, GeePriorityQueueType1Node* n) {
1733         GeePriorityQueueType1Node* _tmp0_;
1734         GeePriorityQueueType1Node* _tmp1_;
1735         GeePriorityQueueType2Node* _tmp2_;
1736         gint _tmp3_ = 0;
1737         GeePriorityQueueType2Node* _tmp6_;
1738         GeePriorityQueueType1Node* _tmp7_;
1739         gint _tmp8_ = 0;
1740         g_return_if_fail (self != NULL);
1741         g_return_if_fail (n != NULL);
1742         _tmp0_ = n;
1743         _gee_priority_queue_add_in_r_prime (self, _tmp0_);
1744         _tmp1_ = n;
1745         _tmp2_ = self->priv->_r_prime;
1746         _tmp3_ = _gee_priority_queue_compare (self, (GeePriorityQueueNode*) _tmp1_, (GeePriorityQueueNode*) _tmp2_);
1747         if (_tmp3_ < 0) {
1748                 GeePriorityQueueType1Node* _tmp4_;
1749                 GeePriorityQueueType2Node* _tmp5_;
1750                 _tmp4_ = n;
1751                 _tmp5_ = self->priv->_r_prime;
1752                 _gee_priority_queue_swap_data (self, (GeePriorityQueueNode*) _tmp4_, (GeePriorityQueueNode*) _tmp5_);
1753         }
1754         _tmp6_ = self->priv->_r_prime;
1755         _tmp7_ = self->priv->_r;
1756         _tmp8_ = _gee_priority_queue_compare (self, (GeePriorityQueueNode*) _tmp6_, (GeePriorityQueueNode*) _tmp7_);
1757         if (_tmp8_ < 0) {
1758                 GeePriorityQueueType2Node* _tmp9_;
1759                 GeePriorityQueueType1Node* _tmp10_;
1760                 _tmp9_ = self->priv->_r_prime;
1761                 _tmp10_ = self->priv->_r;
1762                 _gee_priority_queue_swap_data (self, (GeePriorityQueueNode*) _tmp9_, (GeePriorityQueueNode*) _tmp10_);
1763         }
1764         _gee_priority_queue_check_linkable (self);
1765 }
1766
1767
1768 static gboolean _gee_priority_queue_check_linkable (GeePriorityQueue* self) {
1769         gboolean result = FALSE;
1770         GeePriorityQueueNodePair* _tmp0_;
1771         g_return_val_if_fail (self != NULL, FALSE);
1772         _tmp0_ = self->priv->_lp_head;
1773         if (_tmp0_ != NULL) {
1774                 GeePriorityQueueNodePair* _tmp1_;
1775                 GeePriorityQueueNodePair* pair;
1776                 GeePriorityQueueNodePair* _tmp2_;
1777                 GeePriorityQueueType1Node* _tmp3_;
1778                 GeePriorityQueueType1Node* _tmp4_;
1779                 GeePriorityQueueNodePair* _tmp5_;
1780                 GeePriorityQueueType1Node* _tmp6_;
1781                 GeePriorityQueueType1Node* _tmp7_;
1782                 _tmp1_ = self->priv->_lp_head;
1783                 pair = _tmp1_;
1784                 _tmp2_ = pair;
1785                 _tmp3_ = _tmp2_->node1;
1786                 _tmp4_ = _gee_priority_queue_node_ref0 (_tmp3_);
1787                 _tmp5_ = pair;
1788                 _tmp6_ = _tmp5_->node2;
1789                 _tmp7_ = _gee_priority_queue_node_ref0 (_tmp6_);
1790                 _gee_priority_queue_link (self, _tmp4_, _tmp7_);
1791                 result = TRUE;
1792                 return result;
1793         }
1794         result = FALSE;
1795         return result;
1796 }
1797
1798
1799 static GeePriorityQueueNode* _gee_priority_queue_re_insert (GeePriorityQueue* self, GeePriorityQueueType1Node* n) {
1800         GeePriorityQueueNode* result = NULL;
1801         GeePriorityQueueType1Node* _tmp0_;
1802         GeePriorityQueueType1Node* _tmp1_;
1803         GeePriorityQueueType1Node* _tmp2_;
1804         GeePriorityQueueNode* _tmp3_;
1805         GeePriorityQueueNode* _tmp4_;
1806         GeePriorityQueueNode* parent;
1807         GeePriorityQueueType1Node* _tmp5_;
1808         GeePriorityQueueType1Node* _tmp6_;
1809         g_return_val_if_fail (self != NULL, NULL);
1810         g_return_val_if_fail (n != NULL, NULL);
1811         _tmp0_ = n;
1812         _tmp1_ = self->priv->_r;
1813         _vala_assert (_tmp0_ != _tmp1_, "n != _r");
1814         _tmp2_ = n;
1815         _tmp3_ = ((GeePriorityQueueNode*) _tmp2_)->parent;
1816         _tmp4_ = _gee_priority_queue_node_ref0 (_tmp3_);
1817         parent = _tmp4_;
1818         _tmp5_ = n;
1819         _gee_priority_queue_remove_type1_node (self, _tmp5_, FALSE);
1820         _tmp6_ = n;
1821         _gee_priority_queue_add (self, _tmp6_);
1822         result = parent;
1823         _gee_priority_queue_node_unref0 (n);
1824         return result;
1825 }
1826
1827
1828 static void _gee_priority_queue_adjust (GeePriorityQueue* self, GeePriorityQueueType1Node* p1, GeePriorityQueueType1Node* p2) {
1829         GeePriorityQueueType1Node* _tmp0_;
1830         GeePriorityQueueType1Node* m = NULL;
1831         GeePriorityQueueType1Node* _tmp1_;
1832         guint _tmp2_;
1833         GeePriorityQueueType1Node* _tmp3_;
1834         guint _tmp4_;
1835         GeePriorityQueueType1Node* _tmp9_;
1836         guint _tmp10_;
1837         GeePriorityQueueType1Node* _tmp20_;
1838         GeePriorityQueueType1Node* _tmp21_;
1839         GeePriorityQueueNode* _tmp22_ = NULL;
1840         g_return_if_fail (self != NULL);
1841         g_return_if_fail (p1 != NULL);
1842         g_return_if_fail (p2 != NULL);
1843         _tmp0_ = self->priv->_ll_head;
1844         if (_tmp0_ == NULL) {
1845                 return;
1846         }
1847         _tmp1_ = p1;
1848         _tmp2_ = _tmp1_->lost;
1849         _tmp3_ = p2;
1850         _tmp4_ = _tmp3_->lost;
1851         if (_tmp2_ > _tmp4_) {
1852                 GeePriorityQueueType1Node* _tmp5_;
1853                 GeePriorityQueueType1Node* _tmp6_;
1854                 _tmp5_ = p1;
1855                 _tmp6_ = _gee_priority_queue_node_ref0 (_tmp5_);
1856                 _gee_priority_queue_node_unref0 (m);
1857                 m = _tmp6_;
1858         } else {
1859                 GeePriorityQueueType1Node* _tmp7_;
1860                 GeePriorityQueueType1Node* _tmp8_;
1861                 _tmp7_ = p2;
1862                 _tmp8_ = _gee_priority_queue_node_ref0 (_tmp7_);
1863                 _gee_priority_queue_node_unref0 (m);
1864                 m = _tmp8_;
1865         }
1866         _tmp9_ = m;
1867         _tmp10_ = _tmp9_->lost;
1868         if (_tmp10_ <= ((guint) 1)) {
1869                 GeePriorityQueueType1Node* _tmp11_;
1870                 GeePriorityQueueType1Node* _tmp12_;
1871                 GeePriorityQueueType1Node* _tmp13_;
1872                 GeePriorityQueueType1Node* _tmp14_;
1873                 GeePriorityQueueType1Node* _tmp17_;
1874                 GeePriorityQueueType1Node* _tmp18_;
1875                 GeePriorityQueueType1Node* _tmp19_;
1876                 _tmp11_ = self->priv->_ll_head;
1877                 _tmp12_ = _gee_priority_queue_node_ref0 (_tmp11_);
1878                 _gee_priority_queue_node_unref0 (m);
1879                 m = _tmp12_;
1880                 _tmp13_ = self->priv->_ll_head;
1881                 _tmp14_ = _tmp13_->ll_next;
1882                 if (_tmp14_ != NULL) {
1883                         GeePriorityQueueType1Node* _tmp15_;
1884                         GeePriorityQueueType1Node* _tmp16_;
1885                         _tmp15_ = self->priv->_ll_head;
1886                         _tmp16_ = _tmp15_->ll_next;
1887                         _tmp16_->ll_prev = NULL;
1888                 }
1889                 _tmp17_ = self->priv->_ll_head;
1890                 _tmp18_ = _tmp17_->ll_next;
1891                 _tmp19_ = _gee_priority_queue_node_ref0 (_tmp18_);
1892                 _gee_priority_queue_node_unref0 (self->priv->_ll_head);
1893                 self->priv->_ll_head = _tmp19_;
1894         }
1895         _tmp20_ = m;
1896         _tmp21_ = _gee_priority_queue_node_ref0 (_tmp20_);
1897         _tmp22_ = _gee_priority_queue_re_insert (self, _tmp21_);
1898         _gee_priority_queue_node_unref0 (self->priv->_p);
1899         self->priv->_p = G_TYPE_CHECK_INSTANCE_CAST (_tmp22_, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node);
1900         _gee_priority_queue_node_unref0 (m);
1901 }
1902
1903
1904 static void _gee_priority_queue_delete (GeePriorityQueue* self, GeePriorityQueueNode* n) {
1905         GeePriorityQueueNode* _tmp0_;
1906         gpointer _tmp1_ = NULL;
1907         gpointer _tmp2_;
1908         g_return_if_fail (self != NULL);
1909         g_return_if_fail (n != NULL);
1910         _tmp0_ = n;
1911         _gee_priority_queue_decrease_key (self, _tmp0_);
1912         _tmp1_ = gee_abstract_queue_poll ((GeeAbstractQueue*) self);
1913         _tmp2_ = _tmp1_;
1914         ((_tmp2_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp2_ = (self->priv->g_destroy_func (_tmp2_), NULL));
1915 }
1916
1917
1918 static void _gee_priority_queue_decrease_key (GeePriorityQueue* self, GeePriorityQueueNode* n) {
1919         gboolean _tmp0_ = FALSE;
1920         GeePriorityQueueNode* _tmp1_;
1921         GeePriorityQueueType1Node* _tmp2_;
1922         gboolean _tmp4_;
1923         GeePriorityQueueNode* _tmp5_;
1924         gboolean _tmp6_ = FALSE;
1925         GeePriorityQueueNode* _tmp7_;
1926         GeePriorityQueueType2Node* _tmp8_;
1927         gboolean _tmp12_;
1928         GeePriorityQueueNode* _tmp15_;
1929         GeePriorityQueueType1Node* _tmp16_;
1930         GeePriorityQueueNode* _tmp17_ = NULL;
1931         GeePriorityQueueNode* p_prime;
1932         GeePriorityQueueNode* _tmp18_;
1933         g_return_if_fail (self != NULL);
1934         g_return_if_fail (n != NULL);
1935         _tmp1_ = n;
1936         _tmp2_ = self->priv->_r;
1937         if (_tmp1_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
1938                 _tmp0_ = TRUE;
1939         } else {
1940                 GeePriorityQueueType2Node* _tmp3_;
1941                 _tmp3_ = self->priv->_r_prime;
1942                 _tmp0_ = _tmp3_ == NULL;
1943         }
1944         _tmp4_ = _tmp0_;
1945         if (_tmp4_) {
1946                 return;
1947         }
1948         _tmp5_ = n;
1949         _tmp5_->pending_drop = TRUE;
1950         _tmp7_ = n;
1951         _tmp8_ = self->priv->_r_prime;
1952         if (_tmp7_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
1953                 GeePriorityQueueType2Node* _tmp9_;
1954                 GeePriorityQueueType1Node* _tmp10_;
1955                 gint _tmp11_ = 0;
1956                 _tmp9_ = self->priv->_r_prime;
1957                 _tmp10_ = self->priv->_r;
1958                 _tmp11_ = _gee_priority_queue_compare (self, (GeePriorityQueueNode*) _tmp9_, (GeePriorityQueueNode*) _tmp10_);
1959                 _tmp6_ = _tmp11_ < 0;
1960         } else {
1961                 _tmp6_ = FALSE;
1962         }
1963         _tmp12_ = _tmp6_;
1964         if (_tmp12_) {
1965                 GeePriorityQueueType2Node* _tmp13_;
1966                 GeePriorityQueueType1Node* _tmp14_;
1967                 _tmp13_ = self->priv->_r_prime;
1968                 _tmp14_ = self->priv->_r;
1969                 _gee_priority_queue_swap_data (self, (GeePriorityQueueNode*) _tmp13_, (GeePriorityQueueNode*) _tmp14_);
1970                 return;
1971         }
1972         _tmp15_ = n;
1973         _tmp16_ = _gee_priority_queue_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp15_, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node));
1974         _tmp17_ = _gee_priority_queue_re_insert (self, _tmp16_);
1975         p_prime = _tmp17_;
1976         _tmp18_ = p_prime;
1977         if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp18_, GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE)) {
1978                 GeePriorityQueueType1Node* _tmp19_;
1979                 GeePriorityQueueType1Node* _tmp20_;
1980                 _tmp19_ = self->priv->_p;
1981                 _tmp20_ = self->priv->_p;
1982                 _gee_priority_queue_adjust (self, _tmp19_, _tmp20_);
1983         } else {
1984                 GeePriorityQueueType1Node* _tmp21_;
1985                 GeePriorityQueueNode* _tmp22_;
1986                 _tmp21_ = self->priv->_p;
1987                 _tmp22_ = p_prime;
1988                 _gee_priority_queue_adjust (self, _tmp21_, G_TYPE_CHECK_INSTANCE_CAST (_tmp22_, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node));
1989         }
1990         _gee_priority_queue_node_unref0 (p_prime);
1991 }
1992
1993
1994 static void _gee_priority_queue_add_to (GeePriorityQueue* self, GeePriorityQueueType1Node* node, GeePriorityQueueType1Node* parent) {
1995         GeePriorityQueueType1Node* _tmp0_;
1996         GeePriorityQueueType1Node* _tmp1_;
1997         GeePriorityQueueType1Node* _tmp2_;
1998         g_return_if_fail (self != NULL);
1999         g_return_if_fail (node != NULL);
2000         g_return_if_fail (parent != NULL);
2001         _tmp0_ = parent;
2002         _tmp1_ = node;
2003         gee_priority_queue_type1_node_add (_tmp0_, _tmp1_);
2004         _tmp2_ = parent;
2005         _tmp2_->lost = (guint) 0;
2006 }
2007
2008
2009 static void _gee_priority_queue_add_in_r_prime (GeePriorityQueue* self, GeePriorityQueueType1Node* node) {
2010         GeePriorityQueueType1Node* _tmp0_;
2011         gint _tmp1_ = 0;
2012         gint degree;
2013         GeePriorityQueueType1Node* insertion_point;
2014         gint _tmp2_;
2015         GeePriorityQueueType1Node** _tmp3_;
2016         gint _tmp3__length1;
2017         GeePriorityQueueType1Node* _tmp8_;
2018         GeePriorityQueueType1Node* _tmp41_;
2019         GeePriorityQueueType2Node* _tmp42_;
2020         gint _tmp43_;
2021         GeePriorityQueueType1Node** _tmp44_;
2022         gint _tmp44__length1;
2023         GeePriorityQueueType1Node** _tmp49_;
2024         gint _tmp49__length1;
2025         gint _tmp50_;
2026         GeePriorityQueueType1Node* _tmp51_;
2027         GeePriorityQueueType1Node** _tmp82_;
2028         gint _tmp82__length1;
2029         gint _tmp83_;
2030         GeePriorityQueueType1Node* _tmp84_;
2031         GeePriorityQueueType1Node* _tmp85_;
2032         GeePriorityQueueType1Node* _tmp86_;
2033         g_return_if_fail (self != NULL);
2034         g_return_if_fail (node != NULL);
2035         _tmp0_ = node;
2036         _tmp1_ = gee_priority_queue_node_degree ((GeePriorityQueueNode*) _tmp0_);
2037         degree = _tmp1_;
2038         insertion_point = NULL;
2039         _tmp2_ = degree;
2040         _tmp3_ = self->priv->_a;
2041         _tmp3__length1 = self->priv->_a_length1;
2042         if (_tmp2_ < _tmp3__length1) {
2043                 GeePriorityQueueType1Node** _tmp4_;
2044                 gint _tmp4__length1;
2045                 gint _tmp5_;
2046                 GeePriorityQueueType1Node* _tmp6_;
2047                 GeePriorityQueueType1Node* _tmp7_;
2048                 _tmp4_ = self->priv->_a;
2049                 _tmp4__length1 = self->priv->_a_length1;
2050                 _tmp5_ = degree;
2051                 _tmp6_ = _tmp4_[_tmp5_];
2052                 _tmp7_ = _gee_priority_queue_node_ref0 (_tmp6_);
2053                 _gee_priority_queue_node_unref0 (insertion_point);
2054                 insertion_point = _tmp7_;
2055         }
2056         _tmp8_ = insertion_point;
2057         if (_tmp8_ == NULL) {
2058                 GeePriorityQueueType2Node* _tmp9_;
2059                 GeePriorityQueueType1Node* _tmp10_;
2060                 GeePriorityQueueType2Node* _tmp21_;
2061                 GeePriorityQueueType1Node* _tmp22_;
2062                 GeePriorityQueueType1Node* _tmp23_;
2063                 _tmp9_ = self->priv->_r_prime;
2064                 _tmp10_ = ((GeePriorityQueueNode*) _tmp9_)->type1_children_tail;
2065                 if (_tmp10_ != NULL) {
2066                         GeePriorityQueueType1Node* _tmp11_;
2067                         GeePriorityQueueType2Node* _tmp12_;
2068                         GeePriorityQueueType1Node* _tmp13_;
2069                         GeePriorityQueueType2Node* _tmp14_;
2070                         GeePriorityQueueType1Node* _tmp15_;
2071                         GeePriorityQueueType1Node* _tmp16_;
2072                         GeePriorityQueueType1Node* _tmp17_;
2073                         _tmp11_ = node;
2074                         _tmp12_ = self->priv->_r_prime;
2075                         _tmp13_ = ((GeePriorityQueueNode*) _tmp12_)->type1_children_tail;
2076                         _tmp11_->brothers_prev = _tmp13_;
2077                         _tmp14_ = self->priv->_r_prime;
2078                         _tmp15_ = ((GeePriorityQueueNode*) _tmp14_)->type1_children_tail;
2079                         _tmp16_ = node;
2080                         _tmp17_ = _gee_priority_queue_node_ref0 (_tmp16_);
2081                         _gee_priority_queue_node_unref0 (_tmp15_->brothers_next);
2082                         _tmp15_->brothers_next = _tmp17_;
2083                 } else {
2084                         GeePriorityQueueType2Node* _tmp18_;
2085                         GeePriorityQueueType1Node* _tmp19_;
2086                         GeePriorityQueueType1Node* _tmp20_;
2087                         _tmp18_ = self->priv->_r_prime;
2088                         _tmp19_ = node;
2089                         _tmp20_ = _gee_priority_queue_node_ref0 (_tmp19_);
2090                         _gee_priority_queue_node_unref0 (((GeePriorityQueueNode*) _tmp18_)->type1_children_head);
2091                         ((GeePriorityQueueNode*) _tmp18_)->type1_children_head = _tmp20_;
2092                 }
2093                 _tmp21_ = self->priv->_r_prime;
2094                 _tmp22_ = node;
2095                 _tmp23_ = _gee_priority_queue_node_ref0 (_tmp22_);
2096                 _gee_priority_queue_node_unref0 (((GeePriorityQueueNode*) _tmp21_)->type1_children_tail);
2097                 ((GeePriorityQueueNode*) _tmp21_)->type1_children_tail = _tmp23_;
2098         } else {
2099                 GeePriorityQueueType1Node* _tmp24_;
2100                 GeePriorityQueueType1Node* _tmp25_;
2101                 GeePriorityQueueType1Node* _tmp36_;
2102                 GeePriorityQueueType1Node* _tmp37_;
2103                 GeePriorityQueueType1Node* _tmp38_;
2104                 GeePriorityQueueType1Node* _tmp39_;
2105                 GeePriorityQueueType1Node* _tmp40_;
2106                 _tmp24_ = insertion_point;
2107                 _tmp25_ = _tmp24_->brothers_prev;
2108                 if (_tmp25_ != NULL) {
2109                         GeePriorityQueueType1Node* _tmp26_;
2110                         GeePriorityQueueType1Node* _tmp27_;
2111                         GeePriorityQueueType1Node* _tmp28_;
2112                         GeePriorityQueueType1Node* _tmp29_;
2113                         GeePriorityQueueType1Node* _tmp30_;
2114                         GeePriorityQueueType1Node* _tmp31_;
2115                         GeePriorityQueueType1Node* _tmp32_;
2116                         _tmp26_ = insertion_point;
2117                         _tmp27_ = _tmp26_->brothers_prev;
2118                         _tmp28_ = node;
2119                         _tmp29_ = _gee_priority_queue_node_ref0 (_tmp28_);
2120                         _gee_priority_queue_node_unref0 (_tmp27_->brothers_next);
2121                         _tmp27_->brothers_next = _tmp29_;
2122                         _tmp30_ = node;
2123                         _tmp31_ = insertion_point;
2124                         _tmp32_ = _tmp31_->brothers_prev;
2125                         _tmp30_->brothers_prev = _tmp32_;
2126                 } else {
2127                         GeePriorityQueueType2Node* _tmp33_;
2128                         GeePriorityQueueType1Node* _tmp34_;
2129                         GeePriorityQueueType1Node* _tmp35_;
2130                         _tmp33_ = self->priv->_r_prime;
2131                         _tmp34_ = node;
2132                         _tmp35_ = _gee_priority_queue_node_ref0 (_tmp34_);
2133                         _gee_priority_queue_node_unref0 (((GeePriorityQueueNode*) _tmp33_)->type1_children_head);
2134                         ((GeePriorityQueueNode*) _tmp33_)->type1_children_head = _tmp35_;
2135                 }
2136                 _tmp36_ = node;
2137                 _tmp37_ = insertion_point;
2138                 _tmp38_ = _gee_priority_queue_node_ref0 (_tmp37_);
2139                 _gee_priority_queue_node_unref0 (_tmp36_->brothers_next);
2140                 _tmp36_->brothers_next = _tmp38_;
2141                 _tmp39_ = insertion_point;
2142                 _tmp40_ = node;
2143                 _tmp39_->brothers_prev = _tmp40_;
2144         }
2145         _tmp41_ = node;
2146         _tmp42_ = self->priv->_r_prime;
2147         ((GeePriorityQueueNode*) _tmp41_)->parent = (GeePriorityQueueNode*) _tmp42_;
2148         _tmp43_ = degree;
2149         _tmp44_ = self->priv->_a;
2150         _tmp44__length1 = self->priv->_a_length1;
2151         if (_tmp43_ >= _tmp44__length1) {
2152                 gint _tmp45_;
2153                 gint _tmp46_ = 0;
2154                 gint _tmp47_;
2155                 gint _tmp48_ = 0;
2156                 _tmp45_ = degree;
2157                 _tmp46_ = _tmp45_ + 1;
2158                 self->priv->_a = g_renew (GeePriorityQueueType1Node*, self->priv->_a, _tmp45_ + 1);
2159                 (_tmp46_ > self->priv->_a_length1) ? memset (self->priv->_a + self->priv->_a_length1, 0, sizeof (GeePriorityQueueType1Node*) * (_tmp46_ - self->priv->_a_length1)) : NULL;
2160                 self->priv->_a_length1 = _tmp46_;
2161                 self->priv->__a_size_ = _tmp46_;
2162                 _tmp47_ = degree;
2163                 _tmp48_ = _tmp47_ + 1;
2164                 self->priv->_b = g_renew (gboolean, self->priv->_b, _tmp47_ + 1);
2165                 (_tmp48_ > self->priv->_b_length1) ? memset (self->priv->_b + self->priv->_b_length1, 0, sizeof (gboolean) * (_tmp48_ - self->priv->_b_length1)) : NULL;
2166                 self->priv->_b_length1 = _tmp48_;
2167                 self->priv->__b_size_ = _tmp48_;
2168         }
2169         _tmp49_ = self->priv->_a;
2170         _tmp49__length1 = self->priv->_a_length1;
2171         _tmp50_ = degree;
2172         _tmp51_ = _tmp49_[_tmp50_];
2173         if (_tmp51_ == NULL) {
2174                 gboolean* _tmp52_;
2175                 gint _tmp52__length1;
2176                 gint _tmp53_;
2177                 gboolean _tmp54_;
2178                 _tmp52_ = self->priv->_b;
2179                 _tmp52__length1 = self->priv->_b_length1;
2180                 _tmp53_ = degree;
2181                 _tmp52_[_tmp53_] = TRUE;
2182                 _tmp54_ = _tmp52_[_tmp53_];
2183         } else {
2184                 gboolean* _tmp55_;
2185                 gint _tmp55__length1;
2186                 gint _tmp56_;
2187                 gboolean _tmp57_;
2188                 _tmp55_ = self->priv->_b;
2189                 _tmp55__length1 = self->priv->_b_length1;
2190                 _tmp56_ = degree;
2191                 _tmp57_ = _tmp55_[_tmp56_];
2192                 if (_tmp57_) {
2193                         GeePriorityQueueType1Node* _tmp58_;
2194                         GeePriorityQueueType1Node* _tmp59_;
2195                         GeePriorityQueueType1Node* _tmp60_;
2196                         GeePriorityQueueNodePair* _tmp61_;
2197                         GeePriorityQueueNodePair* pair;
2198                         GeePriorityQueueType1Node* _tmp62_;
2199                         GeePriorityQueueType1Node* _tmp63_;
2200                         GeePriorityQueueNodePair* _tmp64_;
2201                         GeePriorityQueueType1Node* _tmp65_;
2202                         GeePriorityQueueNodePair* _tmp66_;
2203                         GeePriorityQueueNodePair* _tmp67_;
2204                         gboolean* _tmp76_;
2205                         gint _tmp76__length1;
2206                         gint _tmp77_;
2207                         gboolean _tmp78_;
2208                         _tmp58_ = node;
2209                         _tmp59_ = node;
2210                         _tmp60_ = _tmp59_->brothers_next;
2211                         _tmp61_ = gee_priority_queue_node_pair_new (_tmp58_, _tmp60_);
2212                         pair = _tmp61_;
2213                         _tmp62_ = node;
2214                         _tmp63_ = _tmp62_->brothers_next;
2215                         _tmp64_ = pair;
2216                         _tmp63_->pair = _tmp64_;
2217                         _tmp65_ = node;
2218                         _tmp66_ = pair;
2219                         _tmp65_->pair = _tmp66_;
2220                         _tmp67_ = self->priv->_lp_head;
2221                         if (_tmp67_ == NULL) {
2222                                 GeePriorityQueueNodePair* _tmp68_;
2223                                 GeePriorityQueueNodePair* _tmp69_;
2224                                 _tmp68_ = pair;
2225                                 self->priv->_lp_tail = _tmp68_;
2226                                 _tmp69_ = pair;
2227                                 pair = NULL;
2228                                 _gee_priority_queue_node_pair_free0 (self->priv->_lp_head);
2229                                 self->priv->_lp_head = _tmp69_;
2230                         } else {
2231                                 GeePriorityQueueNodePair* _tmp70_;
2232                                 GeePriorityQueueNodePair* _tmp71_;
2233                                 GeePriorityQueueNodePair* _tmp72_;
2234                                 GeePriorityQueueNodePair* _tmp73_;
2235                                 GeePriorityQueueNodePair* _tmp74_;
2236                                 GeePriorityQueueNodePair* _tmp75_;
2237                                 _tmp70_ = pair;
2238                                 _tmp71_ = self->priv->_lp_tail;
2239                                 _tmp70_->lp_prev = _tmp71_;
2240                                 _tmp72_ = self->priv->_lp_tail;
2241                                 _tmp73_ = pair;
2242                                 pair = NULL;
2243                                 _gee_priority_queue_node_pair_free0 (_tmp72_->lp_next);
2244                                 _tmp72_->lp_next = _tmp73_;
2245                                 _tmp74_ = self->priv->_lp_tail;
2246                                 _tmp75_ = _tmp74_->lp_next;
2247                                 self->priv->_lp_tail = _tmp75_;
2248                         }
2249                         _tmp76_ = self->priv->_b;
2250                         _tmp76__length1 = self->priv->_b_length1;
2251                         _tmp77_ = degree;
2252                         _tmp76_[_tmp77_] = FALSE;
2253                         _tmp78_ = _tmp76_[_tmp77_];
2254                         _gee_priority_queue_node_pair_free0 (pair);
2255                 } else {
2256                         gboolean* _tmp79_;
2257                         gint _tmp79__length1;
2258                         gint _tmp80_;
2259                         gboolean _tmp81_;
2260                         _tmp79_ = self->priv->_b;
2261                         _tmp79__length1 = self->priv->_b_length1;
2262                         _tmp80_ = degree;
2263                         _tmp79_[_tmp80_] = TRUE;
2264                         _tmp81_ = _tmp79_[_tmp80_];
2265                 }
2266         }
2267         _tmp82_ = self->priv->_a;
2268         _tmp82__length1 = self->priv->_a_length1;
2269         _tmp83_ = degree;
2270         _tmp84_ = node;
2271         _tmp85_ = _gee_priority_queue_node_ref0 (_tmp84_);
2272         _gee_priority_queue_node_unref0 (_tmp82_[_tmp83_]);
2273         _tmp82_[_tmp83_] = _tmp85_;
2274         _tmp86_ = _tmp82_[_tmp83_];
2275         _gee_priority_queue_node_unref0 (insertion_point);
2276 }
2277
2278
2279 static void _gee_priority_queue_remove_type1_node (GeePriorityQueue* self, GeePriorityQueueType1Node* node, gboolean with_iteration) {
2280         GeePriorityQueueType1Node* _tmp0_;
2281         GeePriorityQueueNode* _tmp1_;
2282         GeePriorityQueueType2Node* _tmp2_;
2283         GeePriorityQueueType1Node* _tmp55_;
2284         GeePriorityQueueType1Node* _tmp56_;
2285         GeePriorityQueueType1Node* _tmp59_;
2286         gboolean _tmp60_;
2287         g_return_if_fail (self != NULL);
2288         g_return_if_fail (node != NULL);
2289         _tmp0_ = node;
2290         _tmp1_ = ((GeePriorityQueueNode*) _tmp0_)->parent;
2291         _tmp2_ = self->priv->_r_prime;
2292         if (_tmp1_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
2293                 GeePriorityQueueType1Node* _tmp3_;
2294                 _tmp3_ = node;
2295                 _gee_priority_queue_updated_degree (self, _tmp3_, FALSE);
2296         } else {
2297                 GeePriorityQueueType1Node* _tmp4_;
2298                 GeePriorityQueueType1Node* _tmp5_;
2299                 GeePriorityQueueType1Node* _tmp16_;
2300                 GeePriorityQueueType1Node* _tmp17_;
2301                 GeePriorityQueueType1Node* _tmp27_;
2302                 GeePriorityQueueNode* _tmp28_;
2303                 _tmp4_ = node;
2304                 _tmp5_ = _tmp4_->ll_prev;
2305                 if (_tmp5_ != NULL) {
2306                         GeePriorityQueueType1Node* _tmp6_;
2307                         GeePriorityQueueType1Node* _tmp7_;
2308                         GeePriorityQueueType1Node* _tmp8_;
2309                         GeePriorityQueueType1Node* _tmp9_;
2310                         GeePriorityQueueType1Node* _tmp10_;
2311                         _tmp6_ = node;
2312                         _tmp7_ = _tmp6_->ll_prev;
2313                         _tmp8_ = node;
2314                         _tmp9_ = _tmp8_->ll_next;
2315                         _tmp10_ = _gee_priority_queue_node_ref0 (_tmp9_);
2316                         _gee_priority_queue_node_unref0 (_tmp7_->ll_next);
2317                         _tmp7_->ll_next = _tmp10_;
2318                 } else {
2319                         GeePriorityQueueType1Node* _tmp11_;
2320                         GeePriorityQueueType1Node* _tmp12_;
2321                         _tmp11_ = self->priv->_ll_head;
2322                         _tmp12_ = node;
2323                         if (_tmp11_ == _tmp12_) {
2324                                 GeePriorityQueueType1Node* _tmp13_;
2325                                 GeePriorityQueueType1Node* _tmp14_;
2326                                 GeePriorityQueueType1Node* _tmp15_;
2327                                 _tmp13_ = node;
2328                                 _tmp14_ = _tmp13_->ll_next;
2329                                 _tmp15_ = _gee_priority_queue_node_ref0 (_tmp14_);
2330                                 _gee_priority_queue_node_unref0 (self->priv->_ll_head);
2331                                 self->priv->_ll_head = _tmp15_;
2332                         }
2333                 }
2334                 _tmp16_ = node;
2335                 _tmp17_ = _tmp16_->ll_next;
2336                 if (_tmp17_ != NULL) {
2337                         GeePriorityQueueType1Node* _tmp18_;
2338                         GeePriorityQueueType1Node* _tmp19_;
2339                         GeePriorityQueueType1Node* _tmp20_;
2340                         GeePriorityQueueType1Node* _tmp21_;
2341                         _tmp18_ = node;
2342                         _tmp19_ = _tmp18_->ll_next;
2343                         _tmp20_ = node;
2344                         _tmp21_ = _tmp20_->ll_prev;
2345                         _tmp19_->ll_prev = _tmp21_;
2346                 } else {
2347                         GeePriorityQueueType1Node* _tmp22_;
2348                         GeePriorityQueueType1Node* _tmp23_;
2349                         _tmp22_ = self->priv->_ll_tail;
2350                         _tmp23_ = node;
2351                         if (_tmp22_ == _tmp23_) {
2352                                 GeePriorityQueueType1Node* _tmp24_;
2353                                 GeePriorityQueueType1Node* _tmp25_;
2354                                 GeePriorityQueueType1Node* _tmp26_;
2355                                 _tmp24_ = node;
2356                                 _tmp25_ = _tmp24_->ll_prev;
2357                                 _tmp26_ = _gee_priority_queue_node_ref0 (_tmp25_);
2358                                 _gee_priority_queue_node_unref0 (self->priv->_ll_tail);
2359                                 self->priv->_ll_tail = _tmp26_;
2360                         }
2361                 }
2362                 _tmp27_ = node;
2363                 _tmp28_ = ((GeePriorityQueueNode*) _tmp27_)->parent;
2364                 if (_tmp28_ != NULL) {
2365                         GeePriorityQueueType1Node* _tmp29_;
2366                         GeePriorityQueueNode* _tmp30_;
2367                         GeePriorityQueueNode* _tmp31_;
2368                         GeePriorityQueueType2Node* _tmp32_;
2369                         _tmp29_ = node;
2370                         _tmp30_ = ((GeePriorityQueueNode*) _tmp29_)->parent;
2371                         _tmp31_ = _tmp30_->parent;
2372                         _tmp32_ = self->priv->_r_prime;
2373                         if (_tmp31_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
2374                                 GeePriorityQueueType1Node* _tmp33_;
2375                                 GeePriorityQueueNode* _tmp34_;
2376                                 _tmp33_ = node;
2377                                 _tmp34_ = ((GeePriorityQueueNode*) _tmp33_)->parent;
2378                                 _gee_priority_queue_updated_degree (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node), TRUE);
2379                         } else {
2380                                 GeePriorityQueueType1Node* _tmp35_;
2381                                 GeePriorityQueueNode* _tmp36_;
2382                                 GeePriorityQueueNode* _tmp37_;
2383                                 _tmp35_ = node;
2384                                 _tmp36_ = ((GeePriorityQueueNode*) _tmp35_)->parent;
2385                                 _tmp37_ = _tmp36_->parent;
2386                                 if (_tmp37_ != NULL) {
2387                                         GeePriorityQueueType1Node* _tmp38_;
2388                                         GeePriorityQueueNode* _tmp39_;
2389                                         GeePriorityQueueType1Node* _tmp40_;
2390                                         GeePriorityQueueType1Node* parent;
2391                                         GeePriorityQueueType1Node* _tmp41_;
2392                                         guint _tmp42_;
2393                                         GeePriorityQueueType1Node* _tmp43_;
2394                                         guint _tmp44_;
2395                                         _tmp38_ = node;
2396                                         _tmp39_ = ((GeePriorityQueueNode*) _tmp38_)->parent;
2397                                         _tmp40_ = _gee_priority_queue_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp39_, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node));
2398                                         parent = _tmp40_;
2399                                         _tmp41_ = parent;
2400                                         _tmp42_ = _tmp41_->lost;
2401                                         _tmp41_->lost = _tmp42_ + 1;
2402                                         _tmp43_ = parent;
2403                                         _tmp44_ = _tmp43_->lost;
2404                                         if (_tmp44_ > ((guint) 1)) {
2405                                                 GeePriorityQueueType1Node* _tmp45_;
2406                                                 GeePriorityQueueType1Node* _tmp53_;
2407                                                 GeePriorityQueueType1Node* _tmp54_;
2408                                                 _tmp45_ = self->priv->_ll_tail;
2409                                                 if (_tmp45_ != NULL) {
2410                                                         GeePriorityQueueType1Node* _tmp46_;
2411                                                         GeePriorityQueueType1Node* _tmp47_;
2412                                                         GeePriorityQueueType1Node* _tmp48_;
2413                                                         GeePriorityQueueType1Node* _tmp49_;
2414                                                         GeePriorityQueueType1Node* _tmp50_;
2415                                                         _tmp46_ = parent;
2416                                                         _tmp47_ = self->priv->_ll_tail;
2417                                                         _tmp46_->ll_prev = _tmp47_;
2418                                                         _tmp48_ = self->priv->_ll_tail;
2419                                                         _tmp49_ = parent;
2420                                                         _tmp50_ = _gee_priority_queue_node_ref0 (_tmp49_);
2421                                                         _gee_priority_queue_node_unref0 (_tmp48_->ll_next);
2422                                                         _tmp48_->ll_next = _tmp50_;
2423                                                 } else {
2424                                                         GeePriorityQueueType1Node* _tmp51_;
2425                                                         GeePriorityQueueType1Node* _tmp52_;
2426                                                         _tmp51_ = parent;
2427                                                         _tmp52_ = _gee_priority_queue_node_ref0 (_tmp51_);
2428                                                         _gee_priority_queue_node_unref0 (self->priv->_ll_head);
2429                                                         self->priv->_ll_head = _tmp52_;
2430                                                 }
2431                                                 _tmp53_ = parent;
2432                                                 _tmp54_ = _gee_priority_queue_node_ref0 (_tmp53_);
2433                                                 _gee_priority_queue_node_unref0 (self->priv->_ll_tail);
2434                                                 self->priv->_ll_tail = _tmp54_;
2435                                         }
2436                                         _gee_priority_queue_node_unref0 (parent);
2437                                 }
2438                         }
2439                 }
2440         }
2441         _tmp55_ = node;
2442         _tmp56_ = self->priv->_p;
2443         if (_tmp55_ == _tmp56_) {
2444                 GeePriorityQueueType1Node* _tmp57_;
2445                 GeePriorityQueueType1Node* _tmp58_;
2446                 _tmp57_ = self->priv->_r;
2447                 _tmp58_ = _gee_priority_queue_node_ref0 (_tmp57_);
2448                 _gee_priority_queue_node_unref0 (self->priv->_p);
2449                 self->priv->_p = _tmp58_;
2450         }
2451         _tmp59_ = node;
2452         gee_priority_queue_type1_node_remove (_tmp59_);
2453         _tmp60_ = with_iteration;
2454         if (_tmp60_) {
2455                 GeePriorityQueueType1Node* _tmp61_;
2456                 GeePriorityQueueNode* _tmp62_;
2457                 GeePriorityQueueType1Node* _tmp71_;
2458                 GeePriorityQueueNode* _tmp72_;
2459                 _tmp61_ = node;
2460                 _tmp62_ = ((GeePriorityQueueNode*) _tmp61_)->iter_prev;
2461                 if (_tmp62_ != NULL) {
2462                         GeePriorityQueueType1Node* _tmp63_;
2463                         GeePriorityQueueNode* _tmp64_;
2464                         GeePriorityQueueType1Node* _tmp65_;
2465                         GeePriorityQueueNode* _tmp66_;
2466                         _tmp63_ = node;
2467                         _tmp64_ = ((GeePriorityQueueNode*) _tmp63_)->iter_prev;
2468                         _tmp65_ = node;
2469                         _tmp66_ = ((GeePriorityQueueNode*) _tmp65_)->iter_next;
2470                         _tmp64_->iter_next = _tmp66_;
2471                 } else {
2472                         GeePriorityQueueNode* _tmp67_;
2473                         GeePriorityQueueType1Node* _tmp68_;
2474                         _tmp67_ = self->priv->_iter_head;
2475                         _tmp68_ = node;
2476                         if (_tmp67_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp68_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
2477                                 GeePriorityQueueType1Node* _tmp69_;
2478                                 GeePriorityQueueNode* _tmp70_;
2479                                 _tmp69_ = node;
2480                                 _tmp70_ = ((GeePriorityQueueNode*) _tmp69_)->iter_next;
2481                                 self->priv->_iter_head = _tmp70_;
2482                         }
2483                 }
2484                 _tmp71_ = node;
2485                 _tmp72_ = ((GeePriorityQueueNode*) _tmp71_)->iter_next;
2486                 if (_tmp72_ != NULL) {
2487                         GeePriorityQueueType1Node* _tmp73_;
2488                         GeePriorityQueueNode* _tmp74_;
2489                         GeePriorityQueueType1Node* _tmp75_;
2490                         GeePriorityQueueNode* _tmp76_;
2491                         _tmp73_ = node;
2492                         _tmp74_ = ((GeePriorityQueueNode*) _tmp73_)->iter_next;
2493                         _tmp75_ = node;
2494                         _tmp76_ = ((GeePriorityQueueNode*) _tmp75_)->iter_prev;
2495                         _tmp74_->iter_prev = _tmp76_;
2496                 } else {
2497                         GeePriorityQueueNode* _tmp77_;
2498                         GeePriorityQueueType1Node* _tmp78_;
2499                         _tmp77_ = self->priv->_iter_tail;
2500                         _tmp78_ = node;
2501                         if (_tmp77_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
2502                                 GeePriorityQueueType1Node* _tmp79_;
2503                                 GeePriorityQueueNode* _tmp80_;
2504                                 _tmp79_ = node;
2505                                 _tmp80_ = ((GeePriorityQueueNode*) _tmp79_)->iter_prev;
2506                                 self->priv->_iter_tail = _tmp80_;
2507                         }
2508                 }
2509         }
2510 }
2511
2512
2513 static void _gee_priority_queue_updated_degree (GeePriorityQueue* self, GeePriorityQueueType1Node* node, gboolean child_removed) {
2514         GeePriorityQueueType1Node* _tmp0_;
2515         gint _tmp1_ = 0;
2516         gint degree;
2517         gint _tmp2_;
2518         GeePriorityQueueType1Node** _tmp3_;
2519         gint _tmp3__length1;
2520         gboolean _tmp8_ = FALSE;
2521         gboolean _tmp9_;
2522         gboolean _tmp13_;
2523         gboolean* _tmp25_;
2524         gint _tmp25__length1;
2525         gint _tmp26_;
2526         gboolean* _tmp27_;
2527         gint _tmp27__length1;
2528         gint _tmp28_;
2529         gboolean _tmp29_;
2530         gboolean _tmp30_;
2531         GeePriorityQueueType1Node** _tmp31_;
2532         gint _tmp31__length1;
2533         gint _tmp32_;
2534         GeePriorityQueueType1Node* _tmp33_;
2535         GeePriorityQueueType1Node* _tmp34_;
2536         GeePriorityQueueType1Node* _tmp64_;
2537         GeePriorityQueueNodePair* _tmp65_;
2538         g_return_if_fail (self != NULL);
2539         g_return_if_fail (node != NULL);
2540         _tmp0_ = node;
2541         _tmp1_ = gee_priority_queue_node_degree ((GeePriorityQueueNode*) _tmp0_);
2542         degree = _tmp1_;
2543         _tmp2_ = degree;
2544         _tmp3_ = self->priv->_a;
2545         _tmp3__length1 = self->priv->_a_length1;
2546         if (_tmp2_ >= _tmp3__length1) {
2547                 gint _tmp4_;
2548                 gint _tmp5_ = 0;
2549                 gint _tmp6_;
2550                 gint _tmp7_ = 0;
2551                 _tmp4_ = degree;
2552                 _tmp5_ = _tmp4_ + 1;
2553                 self->priv->_a = g_renew (GeePriorityQueueType1Node*, self->priv->_a, _tmp4_ + 1);
2554                 (_tmp5_ > self->priv->_a_length1) ? memset (self->priv->_a + self->priv->_a_length1, 0, sizeof (GeePriorityQueueType1Node*) * (_tmp5_ - self->priv->_a_length1)) : NULL;
2555                 self->priv->_a_length1 = _tmp5_;
2556                 self->priv->__a_size_ = _tmp5_;
2557                 _tmp6_ = degree;
2558                 _tmp7_ = _tmp6_ + 1;
2559                 self->priv->_b = g_renew (gboolean, self->priv->_b, _tmp6_ + 1);
2560                 (_tmp7_ > self->priv->_b_length1) ? memset (self->priv->_b + self->priv->_b_length1, 0, sizeof (gboolean) * (_tmp7_ - self->priv->_b_length1)) : NULL;
2561                 self->priv->_b_length1 = _tmp7_;
2562                 self->priv->__b_size_ = _tmp7_;
2563         }
2564         _tmp9_ = child_removed;
2565         if (_tmp9_) {
2566                 GeePriorityQueueType1Node** _tmp10_;
2567                 gint _tmp10__length1;
2568                 gint _tmp11_;
2569                 GeePriorityQueueType1Node* _tmp12_;
2570                 _tmp10_ = self->priv->_a;
2571                 _tmp10__length1 = self->priv->_a_length1;
2572                 _tmp11_ = degree;
2573                 _tmp12_ = _tmp10_[_tmp11_ - 1];
2574                 _tmp8_ = _tmp12_ == NULL;
2575         } else {
2576                 _tmp8_ = FALSE;
2577         }
2578         _tmp13_ = _tmp8_;
2579         if (_tmp13_) {
2580                 GeePriorityQueueType1Node** _tmp14_;
2581                 gint _tmp14__length1;
2582                 gint _tmp15_;
2583                 GeePriorityQueueType1Node* _tmp16_;
2584                 GeePriorityQueueType1Node* _tmp17_;
2585                 GeePriorityQueueType1Node* _tmp18_;
2586                 gboolean* _tmp19_;
2587                 gint _tmp19__length1;
2588                 gint _tmp20_;
2589                 gboolean* _tmp21_;
2590                 gint _tmp21__length1;
2591                 gint _tmp22_;
2592                 gboolean _tmp23_;
2593                 gboolean _tmp24_;
2594                 _tmp14_ = self->priv->_a;
2595                 _tmp14__length1 = self->priv->_a_length1;
2596                 _tmp15_ = degree;
2597                 _tmp16_ = node;
2598                 _tmp17_ = _gee_priority_queue_node_ref0 (_tmp16_);
2599                 _gee_priority_queue_node_unref0 (_tmp14_[_tmp15_ - 1]);
2600                 _tmp14_[_tmp15_ - 1] = _tmp17_;
2601                 _tmp18_ = _tmp14_[_tmp15_ - 1];
2602                 _tmp19_ = self->priv->_b;
2603                 _tmp19__length1 = self->priv->_b_length1;
2604                 _tmp20_ = degree;
2605                 _tmp21_ = self->priv->_b;
2606                 _tmp21__length1 = self->priv->_b_length1;
2607                 _tmp22_ = degree;
2608                 _tmp23_ = _tmp21_[_tmp22_ - 1];
2609                 _tmp19_[_tmp20_ - 1] = !_tmp23_;
2610                 _tmp24_ = _tmp19_[_tmp20_ - 1];
2611         }
2612         _tmp25_ = self->priv->_b;
2613         _tmp25__length1 = self->priv->_b_length1;
2614         _tmp26_ = degree;
2615         _tmp27_ = self->priv->_b;
2616         _tmp27__length1 = self->priv->_b_length1;
2617         _tmp28_ = degree;
2618         _tmp29_ = _tmp27_[_tmp28_];
2619         _tmp25_[_tmp26_] = !_tmp29_;
2620         _tmp30_ = _tmp25_[_tmp26_];
2621         _tmp31_ = self->priv->_a;
2622         _tmp31__length1 = self->priv->_a_length1;
2623         _tmp32_ = degree;
2624         _tmp33_ = _tmp31_[_tmp32_];
2625         _tmp34_ = node;
2626         if (_tmp33_ == _tmp34_) {
2627                 GeePriorityQueueType1Node* _tmp35_;
2628                 GeePriorityQueueType1Node* _tmp36_;
2629                 GeePriorityQueueType1Node* _tmp37_;
2630                 GeePriorityQueueType1Node* next;
2631                 gboolean _tmp38_ = FALSE;
2632                 GeePriorityQueueType1Node* _tmp39_;
2633                 gboolean _tmp43_;
2634                 _tmp35_ = node;
2635                 _tmp36_ = _tmp35_->brothers_next;
2636                 _tmp37_ = _gee_priority_queue_node_ref0 (_tmp36_);
2637                 next = _tmp37_;
2638                 _tmp39_ = next;
2639                 if (_tmp39_ != NULL) {
2640                         GeePriorityQueueType1Node* _tmp40_;
2641                         gint _tmp41_ = 0;
2642                         gint _tmp42_;
2643                         _tmp40_ = next;
2644                         _tmp41_ = gee_priority_queue_node_degree ((GeePriorityQueueNode*) _tmp40_);
2645                         _tmp42_ = degree;
2646                         _tmp38_ = _tmp41_ == _tmp42_;
2647                 } else {
2648                         _tmp38_ = FALSE;
2649                 }
2650                 _tmp43_ = _tmp38_;
2651                 if (_tmp43_) {
2652                         GeePriorityQueueType1Node** _tmp44_;
2653                         gint _tmp44__length1;
2654                         gint _tmp45_;
2655                         GeePriorityQueueType1Node* _tmp46_;
2656                         GeePriorityQueueType1Node* _tmp47_;
2657                         GeePriorityQueueType1Node* _tmp48_;
2658                         _tmp44_ = self->priv->_a;
2659                         _tmp44__length1 = self->priv->_a_length1;
2660                         _tmp45_ = degree;
2661                         _tmp46_ = next;
2662                         _tmp47_ = _gee_priority_queue_node_ref0 (_tmp46_);
2663                         _gee_priority_queue_node_unref0 (_tmp44_[_tmp45_]);
2664                         _tmp44_[_tmp45_] = _tmp47_;
2665                         _tmp48_ = _tmp44_[_tmp45_];
2666                 } else {
2667                         GeePriorityQueueType1Node** _tmp49_;
2668                         gint _tmp49__length1;
2669                         gint _tmp50_;
2670                         GeePriorityQueueType1Node* _tmp51_;
2671                         GeePriorityQueueType1Node** _tmp52_;
2672                         gint _tmp52__length1;
2673                         gint i;
2674                         gint _tmp60_;
2675                         gint _tmp61_ = 0;
2676                         gint _tmp62_;
2677                         gint _tmp63_ = 0;
2678                         _tmp49_ = self->priv->_a;
2679                         _tmp49__length1 = self->priv->_a_length1;
2680                         _tmp50_ = degree;
2681                         _gee_priority_queue_node_unref0 (_tmp49_[_tmp50_]);
2682                         _tmp49_[_tmp50_] = NULL;
2683                         _tmp51_ = _tmp49_[_tmp50_];
2684                         _tmp52_ = self->priv->_a;
2685                         _tmp52__length1 = self->priv->_a_length1;
2686                         i = _tmp52__length1 - 1;
2687                         while (TRUE) {
2688                                 gboolean _tmp53_ = FALSE;
2689                                 gint _tmp54_;
2690                                 gboolean _tmp58_;
2691                                 gint _tmp59_;
2692                                 _tmp54_ = i;
2693                                 if (_tmp54_ >= 0) {
2694                                         GeePriorityQueueType1Node** _tmp55_;
2695                                         gint _tmp55__length1;
2696                                         gint _tmp56_;
2697                                         GeePriorityQueueType1Node* _tmp57_;
2698                                         _tmp55_ = self->priv->_a;
2699                                         _tmp55__length1 = self->priv->_a_length1;
2700                                         _tmp56_ = i;
2701                                         _tmp57_ = _tmp55_[_tmp56_];
2702                                         _tmp53_ = _tmp57_ == NULL;
2703                                 } else {
2704                                         _tmp53_ = FALSE;
2705                                 }
2706                                 _tmp58_ = _tmp53_;
2707                                 if (!_tmp58_) {
2708                                         break;
2709                                 }
2710                                 _tmp59_ = i;
2711                                 i = _tmp59_ - 1;
2712                         }
2713                         _tmp60_ = i;
2714                         _tmp61_ = _tmp60_ + 1;
2715                         self->priv->_a = g_renew (GeePriorityQueueType1Node*, self->priv->_a, _tmp60_ + 1);
2716                         (_tmp61_ > self->priv->_a_length1) ? memset (self->priv->_a + self->priv->_a_length1, 0, sizeof (GeePriorityQueueType1Node*) * (_tmp61_ - self->priv->_a_length1)) : NULL;
2717                         self->priv->_a_length1 = _tmp61_;
2718                         self->priv->__a_size_ = _tmp61_;
2719                         _tmp62_ = i;
2720                         _tmp63_ = _tmp62_ + 1;
2721                         self->priv->_b = g_renew (gboolean, self->priv->_b, _tmp62_ + 1);
2722                         (_tmp63_ > self->priv->_b_length1) ? memset (self->priv->_b + self->priv->_b_length1, 0, sizeof (gboolean) * (_tmp63_ - self->priv->_b_length1)) : NULL;
2723                         self->priv->_b_length1 = _tmp63_;
2724                         self->priv->__b_size_ = _tmp63_;
2725                 }
2726                 _gee_priority_queue_node_unref0 (next);
2727         }
2728         _tmp64_ = node;
2729         _tmp65_ = _tmp64_->pair;
2730         if (_tmp65_ != NULL) {
2731                 GeePriorityQueueType1Node* _tmp66_;
2732                 GeePriorityQueueNodePair* _tmp67_;
2733                 GeePriorityQueueNodePair* pair;
2734                 GeePriorityQueueType1Node* _tmp68_ = NULL;
2735                 GeePriorityQueueNodePair* _tmp69_;
2736                 GeePriorityQueueType1Node* _tmp70_;
2737                 GeePriorityQueueType1Node* _tmp71_;
2738                 GeePriorityQueueType1Node* _tmp76_;
2739                 GeePriorityQueueType1Node* _tmp77_;
2740                 GeePriorityQueueType1Node* other;
2741                 GeePriorityQueueType1Node* _tmp78_;
2742                 GeePriorityQueueType1Node* _tmp79_;
2743                 GeePriorityQueueNodePair* _tmp80_;
2744                 GeePriorityQueueNodePair* _tmp81_;
2745                 GeePriorityQueueNodePair* _tmp88_;
2746                 GeePriorityQueueNodePair* _tmp89_;
2747                 _tmp66_ = node;
2748                 _tmp67_ = _tmp66_->pair;
2749                 pair = _tmp67_;
2750                 _tmp69_ = pair;
2751                 _tmp70_ = _tmp69_->node1;
2752                 _tmp71_ = node;
2753                 if (_tmp70_ == _tmp71_) {
2754                         GeePriorityQueueNodePair* _tmp72_;
2755                         GeePriorityQueueType1Node* _tmp73_;
2756                         _tmp72_ = pair;
2757                         _tmp73_ = _tmp72_->node2;
2758                         _tmp68_ = _tmp73_;
2759                 } else {
2760                         GeePriorityQueueNodePair* _tmp74_;
2761                         GeePriorityQueueType1Node* _tmp75_;
2762                         _tmp74_ = pair;
2763                         _tmp75_ = _tmp74_->node1;
2764                         _tmp68_ = _tmp75_;
2765                 }
2766                 _tmp76_ = _tmp68_;
2767                 _tmp77_ = _gee_priority_queue_node_ref0 (_tmp76_);
2768                 other = _tmp77_;
2769                 _tmp78_ = node;
2770                 _tmp78_->pair = NULL;
2771                 _tmp79_ = other;
2772                 _tmp79_->pair = NULL;
2773                 _tmp80_ = pair;
2774                 _tmp81_ = _tmp80_->lp_next;
2775                 if (_tmp81_ != NULL) {
2776                         GeePriorityQueueNodePair* _tmp82_;
2777                         GeePriorityQueueNodePair* _tmp83_;
2778                         GeePriorityQueueNodePair* _tmp84_;
2779                         GeePriorityQueueNodePair* _tmp85_;
2780                         _tmp82_ = pair;
2781                         _tmp83_ = _tmp82_->lp_next;
2782                         _tmp84_ = pair;
2783                         _tmp85_ = _tmp84_->lp_prev;
2784                         _tmp83_->lp_prev = _tmp85_;
2785                 } else {
2786                         GeePriorityQueueNodePair* _tmp86_;
2787                         GeePriorityQueueNodePair* _tmp87_;
2788                         _tmp86_ = pair;
2789                         _tmp87_ = _tmp86_->lp_prev;
2790                         self->priv->_lp_tail = _tmp87_;
2791                 }
2792                 _tmp88_ = pair;
2793                 _tmp89_ = _tmp88_->lp_prev;
2794                 if (_tmp89_ != NULL) {
2795                         GeePriorityQueueNodePair* _tmp90_;
2796                         GeePriorityQueueNodePair* _tmp91_;
2797                         GeePriorityQueueNodePair* _tmp92_;
2798                         GeePriorityQueueNodePair* _tmp93_;
2799                         _tmp90_ = pair;
2800                         _tmp91_ = _tmp90_->lp_prev;
2801                         _tmp92_ = pair;
2802                         _tmp93_ = _tmp92_->lp_next;
2803                         _tmp92_->lp_next = NULL;
2804                         _gee_priority_queue_node_pair_free0 (_tmp91_->lp_next);
2805                         _tmp91_->lp_next = _tmp93_;
2806                 } else {
2807                         GeePriorityQueueNodePair* _tmp94_;
2808                         GeePriorityQueueNodePair* _tmp95_;
2809                         _tmp94_ = pair;
2810                         _tmp95_ = _tmp94_->lp_next;
2811                         _tmp94_->lp_next = NULL;
2812                         _gee_priority_queue_node_pair_free0 (self->priv->_lp_head);
2813                         self->priv->_lp_head = _tmp95_;
2814                 }
2815                 _gee_priority_queue_node_unref0 (other);
2816         }
2817 }
2818
2819
2820 static void _gee_priority_queue_remove_type2_node (GeePriorityQueue* self, GeePriorityQueueType2Node* node, gboolean with_iteration) {
2821         GeePriorityQueueType2Node* _tmp0_;
2822         GeePriorityQueueNode* _tmp1_;
2823         GeePriorityQueueType2Node* _tmp2_;
2824         gboolean _tmp3_;
2825         g_return_if_fail (self != NULL);
2826         g_return_if_fail (node != NULL);
2827         _tmp0_ = node;
2828         _tmp1_ = ((GeePriorityQueueNode*) _tmp0_)->parent;
2829         _gee_priority_queue_node_unref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node)->type2_child);
2830         G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node)->type2_child = NULL;
2831         _tmp2_ = node;
2832         ((GeePriorityQueueNode*) _tmp2_)->parent = NULL;
2833         _tmp3_ = with_iteration;
2834         if (_tmp3_) {
2835                 GeePriorityQueueType2Node* _tmp4_;
2836                 GeePriorityQueueNode* _tmp5_;
2837                 GeePriorityQueueType2Node* _tmp14_;
2838                 GeePriorityQueueNode* _tmp15_;
2839                 _tmp4_ = node;
2840                 _tmp5_ = ((GeePriorityQueueNode*) _tmp4_)->iter_prev;
2841                 if (_tmp5_ != NULL) {
2842                         GeePriorityQueueType2Node* _tmp6_;
2843                         GeePriorityQueueNode* _tmp7_;
2844                         GeePriorityQueueType2Node* _tmp8_;
2845                         GeePriorityQueueNode* _tmp9_;
2846                         _tmp6_ = node;
2847                         _tmp7_ = ((GeePriorityQueueNode*) _tmp6_)->iter_prev;
2848                         _tmp8_ = node;
2849                         _tmp9_ = ((GeePriorityQueueNode*) _tmp8_)->iter_next;
2850                         _tmp7_->iter_next = _tmp9_;
2851                 } else {
2852                         GeePriorityQueueNode* _tmp10_;
2853                         GeePriorityQueueType2Node* _tmp11_;
2854                         _tmp10_ = self->priv->_iter_head;
2855                         _tmp11_ = node;
2856                         if (_tmp10_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
2857                                 GeePriorityQueueType2Node* _tmp12_;
2858                                 GeePriorityQueueNode* _tmp13_;
2859                                 _tmp12_ = node;
2860                                 _tmp13_ = ((GeePriorityQueueNode*) _tmp12_)->iter_next;
2861                                 self->priv->_iter_head = _tmp13_;
2862                         }
2863                 }
2864                 _tmp14_ = node;
2865                 _tmp15_ = ((GeePriorityQueueNode*) _tmp14_)->iter_next;
2866                 if (_tmp15_ != NULL) {
2867                         GeePriorityQueueType2Node* _tmp16_;
2868                         GeePriorityQueueNode* _tmp17_;
2869                         GeePriorityQueueType2Node* _tmp18_;
2870                         GeePriorityQueueNode* _tmp19_;
2871                         _tmp16_ = node;
2872                         _tmp17_ = ((GeePriorityQueueNode*) _tmp16_)->iter_next;
2873                         _tmp18_ = node;
2874                         _tmp19_ = ((GeePriorityQueueNode*) _tmp18_)->iter_prev;
2875                         _tmp17_->iter_prev = _tmp19_;
2876                 } else {
2877                         GeePriorityQueueNode* _tmp20_;
2878                         GeePriorityQueueType2Node* _tmp21_;
2879                         _tmp20_ = self->priv->_iter_tail;
2880                         _tmp21_ = node;
2881                         if (_tmp20_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp21_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode)) {
2882                                 GeePriorityQueueType2Node* _tmp22_;
2883                                 GeePriorityQueueNode* _tmp23_;
2884                                 _tmp22_ = node;
2885                                 _tmp23_ = ((GeePriorityQueueNode*) _tmp22_)->iter_prev;
2886                                 self->priv->_iter_tail = _tmp23_;
2887                         }
2888                 }
2889         }
2890 }
2891
2892
2893 GCompareDataFunc gee_priority_queue_get_compare_func (GeePriorityQueue* self, gpointer* result_target) {
2894         GCompareDataFunc result;
2895         GCompareDataFunc _tmp0_;
2896         void* _tmp0__target;
2897         GCompareDataFunc _tmp1_;
2898         void* _tmp1__target;
2899         g_return_val_if_fail (self != NULL, NULL);
2900         _tmp0_ = self->priv->_compare_func;
2901         _tmp0__target = self->priv->_compare_func_target;
2902         _tmp1_ = _tmp0_;
2903         _tmp1__target = _tmp0__target;
2904         *result_target = _tmp1__target;
2905         result = _tmp1_;
2906         return result;
2907 }
2908
2909
2910 static void gee_priority_queue_set_compare_func (GeePriorityQueue* self, GCompareDataFunc value, gpointer value_target) {
2911         GCompareDataFunc _tmp0_;
2912         void* _tmp0__target;
2913         g_return_if_fail (self != NULL);
2914         _tmp0_ = value;
2915         _tmp0__target = value_target;
2916         (self->priv->_compare_func_target_destroy_notify == NULL) ? NULL : (self->priv->_compare_func_target_destroy_notify (self->priv->_compare_func_target), NULL);
2917         self->priv->_compare_func = NULL;
2918         self->priv->_compare_func_target = NULL;
2919         self->priv->_compare_func_target_destroy_notify = NULL;
2920         self->priv->_compare_func = _tmp0_;
2921         self->priv->_compare_func_target = _tmp0__target;
2922         self->priv->_compare_func_target_destroy_notify = NULL;
2923 }
2924
2925
2926 static gint gee_priority_queue_real_get_capacity (GeeAbstractQueue* base) {
2927         gint result;
2928         GeePriorityQueue* self;
2929         self = (GeePriorityQueue*) base;
2930         result = GEE_QUEUE_UNBOUNDED_CAPACITY;
2931         return result;
2932 }
2933
2934
2935 static gint gee_priority_queue_real_get_remaining_capacity (GeeAbstractQueue* base) {
2936         gint result;
2937         GeePriorityQueue* self;
2938         self = (GeePriorityQueue*) base;
2939         result = GEE_QUEUE_UNBOUNDED_CAPACITY;
2940         return result;
2941 }
2942
2943
2944 static gboolean gee_priority_queue_real_get_is_full (GeeAbstractQueue* base) {
2945         gboolean result;
2946         GeePriorityQueue* self;
2947         self = (GeePriorityQueue*) base;
2948         result = FALSE;
2949         return result;
2950 }
2951
2952
2953 static gboolean gee_priority_queue_real_get_read_only (GeeAbstractCollection* base) {
2954         gboolean result;
2955         GeePriorityQueue* self;
2956         self = (GeePriorityQueue*) base;
2957         result = FALSE;
2958         return result;
2959 }
2960
2961
2962 static gint gee_priority_queue_real_get_size (GeeAbstractCollection* base) {
2963         gint result;
2964         GeePriorityQueue* self;
2965         gint _tmp0_;
2966         self = (GeePriorityQueue*) base;
2967         _tmp0_ = self->priv->_size;
2968         result = _tmp0_;
2969         return result;
2970 }
2971
2972
2973 static GeePriorityQueueNode* gee_priority_queue_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail) {
2974         GeePriorityQueueNode* self = NULL;
2975         gconstpointer _tmp0_;
2976         gpointer _tmp1_;
2977         GeePriorityQueueNode* _tmp2_;
2978         GeePriorityQueueNode* _tmp3_;
2979         GeePriorityQueueNode* _tmp5_;
2980         self = (GeePriorityQueueNode*) g_type_create_instance (object_type);
2981         self->priv->g_type = g_type;
2982         self->priv->g_dup_func = g_dup_func;
2983         self->priv->g_destroy_func = g_destroy_func;
2984         _tmp0_ = data;
2985         _tmp1_ = ((_tmp0_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
2986         _g_destroy_func0 (self->data);
2987         self->data = _tmp1_;
2988         _tmp2_ = *tail;
2989         self->iter_prev = _tmp2_;
2990         *tail = self;
2991         _tmp3_ = self->iter_prev;
2992         if (_tmp3_ != NULL) {
2993                 GeePriorityQueueNode* _tmp4_;
2994                 _tmp4_ = self->iter_prev;
2995                 _tmp4_->iter_next = self;
2996         }
2997         _tmp5_ = *head;
2998         if (_tmp5_ == NULL) {
2999                 *head = self;
3000         }
3001         return self;
3002 }
3003
3004
3005 static inline gint gee_priority_queue_node_degree (GeePriorityQueueNode* self) {
3006         gint result = 0;
3007         gint _tmp0_;
3008         g_return_val_if_fail (self != NULL, 0);
3009         _tmp0_ = self->type1_children_count;
3010         result = _tmp0_;
3011         return result;
3012 }
3013
3014
3015 static void gee_priority_queue_value_node_init (GValue* value) {
3016         value->data[0].v_pointer = NULL;
3017 }
3018
3019
3020 static void gee_priority_queue_value_node_free_value (GValue* value) {
3021         if (value->data[0].v_pointer) {
3022                 gee_priority_queue_node_unref (value->data[0].v_pointer);
3023         }
3024 }
3025
3026
3027 static void gee_priority_queue_value_node_copy_value (const GValue* src_value, GValue* dest_value) {
3028         if (src_value->data[0].v_pointer) {
3029                 dest_value->data[0].v_pointer = gee_priority_queue_node_ref (src_value->data[0].v_pointer);
3030         } else {
3031                 dest_value->data[0].v_pointer = NULL;
3032         }
3033 }
3034
3035
3036 static gpointer gee_priority_queue_value_node_peek_pointer (const GValue* value) {
3037         return value->data[0].v_pointer;
3038 }
3039
3040
3041 static gchar* gee_priority_queue_value_node_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
3042         if (collect_values[0].v_pointer) {
3043                 GeePriorityQueueNode* object;
3044                 object = collect_values[0].v_pointer;
3045                 if (object->parent_instance.g_class == NULL) {
3046                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
3047                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
3048                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
3049                 }
3050                 value->data[0].v_pointer = gee_priority_queue_node_ref (object);
3051         } else {
3052                 value->data[0].v_pointer = NULL;
3053         }
3054         return NULL;
3055 }
3056
3057
3058 static gchar* gee_priority_queue_value_node_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
3059         GeePriorityQueueNode** object_p;
3060         object_p = collect_values[0].v_pointer;
3061         if (!object_p) {
3062                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
3063         }
3064         if (!value->data[0].v_pointer) {
3065                 *object_p = NULL;
3066         } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
3067                 *object_p = value->data[0].v_pointer;
3068         } else {
3069                 *object_p = gee_priority_queue_node_ref (value->data[0].v_pointer);
3070         }
3071         return NULL;
3072 }
3073
3074
3075 static GParamSpec* gee_priority_queue_param_spec_node (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
3076         GeePriorityQueueParamSpecNode* spec;
3077         g_return_val_if_fail (g_type_is_a (object_type, GEE_PRIORITY_QUEUE_TYPE_NODE), NULL);
3078         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
3079         G_PARAM_SPEC (spec)->value_type = object_type;
3080         return G_PARAM_SPEC (spec);
3081 }
3082
3083
3084 static gpointer gee_priority_queue_value_get_node (const GValue* value) {
3085         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_PRIORITY_QUEUE_TYPE_NODE), NULL);
3086         return value->data[0].v_pointer;
3087 }
3088
3089
3090 static void gee_priority_queue_value_set_node (GValue* value, gpointer v_object) {
3091         GeePriorityQueueNode* old;
3092         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_PRIORITY_QUEUE_TYPE_NODE));
3093         old = value->data[0].v_pointer;
3094         if (v_object) {
3095                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_PRIORITY_QUEUE_TYPE_NODE));
3096                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
3097                 value->data[0].v_pointer = v_object;
3098                 gee_priority_queue_node_ref (value->data[0].v_pointer);
3099         } else {
3100                 value->data[0].v_pointer = NULL;
3101         }
3102         if (old) {
3103                 gee_priority_queue_node_unref (old);
3104         }
3105 }
3106
3107
3108 static void gee_priority_queue_value_take_node (GValue* value, gpointer v_object) {
3109         GeePriorityQueueNode* old;
3110         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_PRIORITY_QUEUE_TYPE_NODE));
3111         old = value->data[0].v_pointer;
3112         if (v_object) {
3113                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_PRIORITY_QUEUE_TYPE_NODE));
3114                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
3115                 value->data[0].v_pointer = v_object;
3116         } else {
3117                 value->data[0].v_pointer = NULL;
3118         }
3119         if (old) {
3120                 gee_priority_queue_node_unref (old);
3121         }
3122 }
3123
3124
3125 static void gee_priority_queue_node_class_init (GeePriorityQueueNodeClass * klass) {
3126         gee_priority_queue_node_parent_class = g_type_class_peek_parent (klass);
3127         GEE_PRIORITY_QUEUE_NODE_CLASS (klass)->finalize = gee_priority_queue_node_finalize;
3128         g_type_class_add_private (klass, sizeof (GeePriorityQueueNodePrivate));
3129 }
3130
3131
3132 static void gee_priority_queue_node_instance_init (GeePriorityQueueNode * self) {
3133         self->priv = GEE_PRIORITY_QUEUE_NODE_GET_PRIVATE (self);
3134         self->parent = NULL;
3135         self->type1_children_head = NULL;
3136         self->type1_children_tail = NULL;
3137         self->iter_next = NULL;
3138         self->ref_count = 1;
3139 }
3140
3141
3142 static void gee_priority_queue_node_finalize (GeePriorityQueueNode* obj) {
3143         GeePriorityQueueNode * self;
3144         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode);
3145         ((self->data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->data = (self->priv->g_destroy_func (self->data), NULL));
3146         _gee_priority_queue_node_unref0 (self->type1_children_head);
3147         _gee_priority_queue_node_unref0 (self->type1_children_tail);
3148 }
3149
3150
3151 static GType gee_priority_queue_node_get_type (void) {
3152         static volatile gsize gee_priority_queue_node_type_id__volatile = 0;
3153         if (g_once_init_enter (&gee_priority_queue_node_type_id__volatile)) {
3154                 static const GTypeValueTable g_define_type_value_table = { gee_priority_queue_value_node_init, gee_priority_queue_value_node_free_value, gee_priority_queue_value_node_copy_value, gee_priority_queue_value_node_peek_pointer, "p", gee_priority_queue_value_node_collect_value, "p", gee_priority_queue_value_node_lcopy_value };
3155                 static const GTypeInfo g_define_type_info = { sizeof (GeePriorityQueueNodeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_priority_queue_node_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePriorityQueueNode), 0, (GInstanceInitFunc) gee_priority_queue_node_instance_init, &g_define_type_value_table };
3156                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
3157                 GType gee_priority_queue_node_type_id;
3158                 gee_priority_queue_node_type_id = g_type_register_fundamental (g_type_fundamental_next (), "GeePriorityQueueNode", &g_define_type_info, &g_define_type_fundamental_info, G_TYPE_FLAG_ABSTRACT);
3159                 g_once_init_leave (&gee_priority_queue_node_type_id__volatile, gee_priority_queue_node_type_id);
3160         }
3161         return gee_priority_queue_node_type_id__volatile;
3162 }
3163
3164
3165 static gpointer gee_priority_queue_node_ref (gpointer instance) {
3166         GeePriorityQueueNode* self;
3167         self = instance;
3168         g_atomic_int_inc (&self->ref_count);
3169         return instance;
3170 }
3171
3172
3173 static void gee_priority_queue_node_unref (gpointer instance) {
3174         GeePriorityQueueNode* self;
3175         self = instance;
3176         if (g_atomic_int_dec_and_test (&self->ref_count)) {
3177                 GEE_PRIORITY_QUEUE_NODE_GET_CLASS (self)->finalize (self);
3178                 g_type_free_instance ((GTypeInstance *) self);
3179         }
3180 }
3181
3182
3183 static GeePriorityQueueType1Node* gee_priority_queue_type1_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail) {
3184         GeePriorityQueueType1Node* self = NULL;
3185         gconstpointer _tmp0_;
3186         _tmp0_ = data;
3187         self = (GeePriorityQueueType1Node*) gee_priority_queue_node_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp0_, head, tail);
3188         self->priv->g_type = g_type;
3189         self->priv->g_dup_func = g_dup_func;
3190         self->priv->g_destroy_func = g_destroy_func;
3191         return self;
3192 }
3193
3194
3195 static GeePriorityQueueType1Node* gee_priority_queue_type1_node_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail) {
3196         return gee_priority_queue_type1_node_construct (GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, g_type, g_dup_func, g_destroy_func, data, head, tail);
3197 }
3198
3199
3200 static inline void gee_priority_queue_type1_node_add (GeePriorityQueueType1Node* self, GeePriorityQueueType1Node* node) {
3201         GeePriorityQueueType1Node* _tmp0_;
3202         GeePriorityQueueType1Node* _tmp1_;
3203         GeePriorityQueueType1Node* _tmp6_;
3204         GeePriorityQueueType1Node* _tmp10_;
3205         GeePriorityQueueType1Node* _tmp11_;
3206         gint _tmp12_;
3207         g_return_if_fail (self != NULL);
3208         g_return_if_fail (node != NULL);
3209         _tmp0_ = node;
3210         ((GeePriorityQueueNode*) _tmp0_)->parent = (GeePriorityQueueNode*) self;
3211         _tmp1_ = ((GeePriorityQueueNode*) self)->type1_children_head;
3212         if (_tmp1_ == NULL) {
3213                 GeePriorityQueueType1Node* _tmp2_;
3214                 GeePriorityQueueType1Node* _tmp3_;
3215                 _tmp2_ = node;
3216                 _tmp3_ = _gee_priority_queue_node_ref0 (_tmp2_);
3217                 _gee_priority_queue_node_unref0 (((GeePriorityQueueNode*) self)->type1_children_head);
3218                 ((GeePriorityQueueNode*) self)->type1_children_head = _tmp3_;
3219         } else {
3220                 GeePriorityQueueType1Node* _tmp4_;
3221                 GeePriorityQueueType1Node* _tmp5_;
3222                 _tmp4_ = node;
3223                 _tmp5_ = ((GeePriorityQueueNode*) self)->type1_children_tail;
3224                 _tmp4_->brothers_prev = _tmp5_;
3225         }
3226         _tmp6_ = ((GeePriorityQueueNode*) self)->type1_children_tail;
3227         if (_tmp6_ != NULL) {
3228                 GeePriorityQueueType1Node* _tmp7_;
3229                 GeePriorityQueueType1Node* _tmp8_;
3230                 GeePriorityQueueType1Node* _tmp9_;
3231                 _tmp7_ = ((GeePriorityQueueNode*) self)->type1_children_tail;
3232                 _tmp8_ = node;
3233                 _tmp9_ = _gee_priority_queue_node_ref0 (_tmp8_);
3234                 _gee_priority_queue_node_unref0 (_tmp7_->brothers_next);
3235                 _tmp7_->brothers_next = _tmp9_;
3236         }
3237         _tmp10_ = node;
3238         _tmp11_ = _gee_priority_queue_node_ref0 (_tmp10_);
3239         _gee_priority_queue_node_unref0 (((GeePriorityQueueNode*) self)->type1_children_tail);
3240         ((GeePriorityQueueNode*) self)->type1_children_tail = _tmp11_;
3241         _tmp12_ = ((GeePriorityQueueNode*) self)->type1_children_count;
3242         ((GeePriorityQueueNode*) self)->type1_children_count = _tmp12_ + 1;
3243 }
3244
3245
3246 static inline void gee_priority_queue_type1_node_remove (GeePriorityQueueType1Node* self) {
3247         GeePriorityQueueType1Node* _tmp0_;
3248         GeePriorityQueueType1Node* _tmp7_;
3249         GeePriorityQueueNode* _tmp13_;
3250         gint _tmp14_;
3251         g_return_if_fail (self != NULL);
3252         _tmp0_ = self->brothers_prev;
3253         if (_tmp0_ == NULL) {
3254                 GeePriorityQueueNode* _tmp1_;
3255                 GeePriorityQueueType1Node* _tmp2_;
3256                 GeePriorityQueueType1Node* _tmp3_;
3257                 _tmp1_ = ((GeePriorityQueueNode*) self)->parent;
3258                 _tmp2_ = self->brothers_next;
3259                 _tmp3_ = _gee_priority_queue_node_ref0 (_tmp2_);
3260                 _gee_priority_queue_node_unref0 (_tmp1_->type1_children_head);
3261                 _tmp1_->type1_children_head = _tmp3_;
3262         } else {
3263                 GeePriorityQueueType1Node* _tmp4_;
3264                 GeePriorityQueueType1Node* _tmp5_;
3265                 GeePriorityQueueType1Node* _tmp6_;
3266                 _tmp4_ = self->brothers_prev;
3267                 _tmp5_ = self->brothers_next;
3268                 _tmp6_ = _gee_priority_queue_node_ref0 (_tmp5_);
3269                 _gee_priority_queue_node_unref0 (_tmp4_->brothers_next);
3270                 _tmp4_->brothers_next = _tmp6_;
3271         }
3272         _tmp7_ = self->brothers_next;
3273         if (_tmp7_ == NULL) {
3274                 GeePriorityQueueNode* _tmp8_;
3275                 GeePriorityQueueType1Node* _tmp9_;
3276                 GeePriorityQueueType1Node* _tmp10_;
3277                 _tmp8_ = ((GeePriorityQueueNode*) self)->parent;
3278                 _tmp9_ = self->brothers_prev;
3279                 _tmp10_ = _gee_priority_queue_node_ref0 (_tmp9_);
3280                 _gee_priority_queue_node_unref0 (_tmp8_->type1_children_tail);
3281                 _tmp8_->type1_children_tail = _tmp10_;
3282         } else {
3283                 GeePriorityQueueType1Node* _tmp11_;
3284                 GeePriorityQueueType1Node* _tmp12_;
3285                 _tmp11_ = self->brothers_next;
3286                 _tmp12_ = self->brothers_prev;
3287                 _tmp11_->brothers_prev = _tmp12_;
3288         }
3289         _tmp13_ = ((GeePriorityQueueNode*) self)->parent;
3290         _tmp14_ = _tmp13_->type1_children_count;
3291         _tmp13_->type1_children_count = _tmp14_ - 1;
3292         ((GeePriorityQueueNode*) self)->parent = NULL;
3293         self->brothers_prev = NULL;
3294         _gee_priority_queue_node_unref0 (self->brothers_next);
3295         self->brothers_next = NULL;
3296 }
3297
3298
3299 static void gee_priority_queue_type1_node_class_init (GeePriorityQueueType1NodeClass * klass) {
3300         gee_priority_queue_type1_node_parent_class = g_type_class_peek_parent (klass);
3301         GEE_PRIORITY_QUEUE_NODE_CLASS (klass)->finalize = gee_priority_queue_type1_node_finalize;
3302         g_type_class_add_private (klass, sizeof (GeePriorityQueueType1NodePrivate));
3303 }
3304
3305
3306 static void gee_priority_queue_type1_node_instance_init (GeePriorityQueueType1Node * self) {
3307         self->priv = GEE_PRIORITY_QUEUE_TYPE1_NODE_GET_PRIVATE (self);
3308         self->brothers_prev = NULL;
3309         self->brothers_next = NULL;
3310         self->type2_child = NULL;
3311         self->ll_prev = NULL;
3312         self->ll_next = NULL;
3313         self->pair = NULL;
3314 }
3315
3316
3317 static void gee_priority_queue_type1_node_finalize (GeePriorityQueueNode* obj) {
3318         GeePriorityQueueType1Node * self;
3319         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_PRIORITY_QUEUE_TYPE_TYPE1_NODE, GeePriorityQueueType1Node);
3320         _gee_priority_queue_node_unref0 (self->brothers_next);
3321         _gee_priority_queue_node_unref0 (self->type2_child);
3322         _gee_priority_queue_node_unref0 (self->ll_next);
3323         GEE_PRIORITY_QUEUE_NODE_CLASS (gee_priority_queue_type1_node_parent_class)->finalize (obj);
3324 }
3325
3326
3327 static GType gee_priority_queue_type1_node_get_type (void) {
3328         static volatile gsize gee_priority_queue_type1_node_type_id__volatile = 0;
3329         if (g_once_init_enter (&gee_priority_queue_type1_node_type_id__volatile)) {
3330                 static const GTypeInfo g_define_type_info = { sizeof (GeePriorityQueueType1NodeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_priority_queue_type1_node_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePriorityQueueType1Node), 0, (GInstanceInitFunc) gee_priority_queue_type1_node_instance_init, NULL };
3331                 GType gee_priority_queue_type1_node_type_id;
3332                 gee_priority_queue_type1_node_type_id = g_type_register_static (GEE_PRIORITY_QUEUE_TYPE_NODE, "GeePriorityQueueType1Node", &g_define_type_info, 0);
3333                 g_once_init_leave (&gee_priority_queue_type1_node_type_id__volatile, gee_priority_queue_type1_node_type_id);
3334         }
3335         return gee_priority_queue_type1_node_type_id__volatile;
3336 }
3337
3338
3339 static GeePriorityQueueType2Node* gee_priority_queue_type2_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail) {
3340         GeePriorityQueueType2Node* self = NULL;
3341         gconstpointer _tmp0_;
3342         _tmp0_ = data;
3343         self = (GeePriorityQueueType2Node*) gee_priority_queue_node_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp0_, head, tail);
3344         self->priv->g_type = g_type;
3345         self->priv->g_dup_func = g_dup_func;
3346         self->priv->g_destroy_func = g_destroy_func;
3347         return self;
3348 }
3349
3350
3351 static GeePriorityQueueType2Node* gee_priority_queue_type2_node_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, GeePriorityQueueNode** head, GeePriorityQueueNode** tail) {
3352         return gee_priority_queue_type2_node_construct (GEE_PRIORITY_QUEUE_TYPE_TYPE2_NODE, g_type, g_dup_func, g_destroy_func, data, head, tail);
3353 }
3354
3355
3356 static void gee_priority_queue_type2_node_class_init (GeePriorityQueueType2NodeClass * klass) {
3357         gee_priority_queue_type2_node_parent_class = g_type_class_peek_parent (klass);
3358         g_type_class_add_private (klass, sizeof (GeePriorityQueueType2NodePrivate));
3359 }
3360
3361
3362 static void gee_priority_queue_type2_node_instance_init (GeePriorityQueueType2Node * self) {
3363         self->priv = GEE_PRIORITY_QUEUE_TYPE2_NODE_GET_PRIVATE (self);
3364 }
3365
3366
3367 static GType gee_priority_queue_type2_node_get_type (void) {
3368         static volatile gsize gee_priority_queue_type2_node_type_id__volatile = 0;
3369         if (g_once_init_enter (&gee_priority_queue_type2_node_type_id__volatile)) {
3370                 static const GTypeInfo g_define_type_info = { sizeof (GeePriorityQueueType2NodeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_priority_queue_type2_node_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePriorityQueueType2Node), 0, (GInstanceInitFunc) gee_priority_queue_type2_node_instance_init, NULL };
3371                 GType gee_priority_queue_type2_node_type_id;
3372                 gee_priority_queue_type2_node_type_id = g_type_register_static (GEE_PRIORITY_QUEUE_TYPE_NODE, "GeePriorityQueueType2Node", &g_define_type_info, 0);
3373                 g_once_init_leave (&gee_priority_queue_type2_node_type_id__volatile, gee_priority_queue_type2_node_type_id);
3374         }
3375         return gee_priority_queue_type2_node_type_id__volatile;
3376 }
3377
3378
3379 static GeePriorityQueueDummyNode* gee_priority_queue_dummy_node_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueueNode** prev_next, GeePriorityQueueNode** next_prev, GeePriorityQueueNode* iter_prev, GeePriorityQueueNode* iter_next) {
3380         GeePriorityQueueDummyNode* self = NULL;
3381         GeePriorityQueueNode* _tmp0_;
3382         GeePriorityQueueNode* _tmp1_;
3383         GeePriorityQueueNode* _tmp2_;
3384         self = (GeePriorityQueueDummyNode*) gee_priority_queue_node_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, NULL, prev_next, next_prev);
3385         self->priv->g_type = g_type;
3386         self->priv->g_dup_func = g_dup_func;
3387         self->priv->g_destroy_func = g_destroy_func;
3388         _tmp0_ = iter_prev;
3389         ((GeePriorityQueueNode*) self)->iter_prev = _tmp0_;
3390         _tmp1_ = iter_next;
3391         ((GeePriorityQueueNode*) self)->iter_next = _tmp1_;
3392         *next_prev = (GeePriorityQueueNode*) self;
3393         _tmp2_ = *next_prev;
3394         *prev_next = _tmp2_;
3395         return self;
3396 }
3397
3398
3399 static GeePriorityQueueDummyNode* gee_priority_queue_dummy_node_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueueNode** prev_next, GeePriorityQueueNode** next_prev, GeePriorityQueueNode* iter_prev, GeePriorityQueueNode* iter_next) {
3400         return gee_priority_queue_dummy_node_construct (GEE_PRIORITY_QUEUE_TYPE_DUMMY_NODE, g_type, g_dup_func, g_destroy_func, prev_next, next_prev, iter_prev, iter_next);
3401 }
3402
3403
3404 static void gee_priority_queue_dummy_node_class_init (GeePriorityQueueDummyNodeClass * klass) {
3405         gee_priority_queue_dummy_node_parent_class = g_type_class_peek_parent (klass);
3406         g_type_class_add_private (klass, sizeof (GeePriorityQueueDummyNodePrivate));
3407 }
3408
3409
3410 static void gee_priority_queue_dummy_node_instance_init (GeePriorityQueueDummyNode * self) {
3411         self->priv = GEE_PRIORITY_QUEUE_DUMMY_NODE_GET_PRIVATE (self);
3412 }
3413
3414
3415 static GType gee_priority_queue_dummy_node_get_type (void) {
3416         static volatile gsize gee_priority_queue_dummy_node_type_id__volatile = 0;
3417         if (g_once_init_enter (&gee_priority_queue_dummy_node_type_id__volatile)) {
3418                 static const GTypeInfo g_define_type_info = { sizeof (GeePriorityQueueDummyNodeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_priority_queue_dummy_node_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePriorityQueueDummyNode), 0, (GInstanceInitFunc) gee_priority_queue_dummy_node_instance_init, NULL };
3419                 GType gee_priority_queue_dummy_node_type_id;
3420                 gee_priority_queue_dummy_node_type_id = g_type_register_static (GEE_PRIORITY_QUEUE_TYPE_NODE, "GeePriorityQueueDummyNode", &g_define_type_info, 0);
3421                 g_once_init_leave (&gee_priority_queue_dummy_node_type_id__volatile, gee_priority_queue_dummy_node_type_id);
3422         }
3423         return gee_priority_queue_dummy_node_type_id__volatile;
3424 }
3425
3426
3427 static GeePriorityQueueNodePair* gee_priority_queue_node_pair_new (GeePriorityQueueType1Node* node1, GeePriorityQueueType1Node* node2) {
3428         GeePriorityQueueNodePair* self;
3429         GeePriorityQueueType1Node* _tmp0_;
3430         GeePriorityQueueType1Node* _tmp1_;
3431         g_return_val_if_fail (node1 != NULL, NULL);
3432         g_return_val_if_fail (node2 != NULL, NULL);
3433         self = g_slice_new0 (GeePriorityQueueNodePair);
3434         gee_priority_queue_node_pair_instance_init (self);
3435         _tmp0_ = node1;
3436         self->node1 = _tmp0_;
3437         _tmp1_ = node2;
3438         self->node2 = _tmp1_;
3439         return self;
3440 }
3441
3442
3443 static void gee_priority_queue_node_pair_instance_init (GeePriorityQueueNodePair * self) {
3444         self->lp_prev = NULL;
3445         self->lp_next = NULL;
3446         self->node1 = NULL;
3447         self->node2 = NULL;
3448 }
3449
3450
3451 static void gee_priority_queue_node_pair_free (GeePriorityQueueNodePair* self) {
3452         _gee_priority_queue_node_pair_free0 (self->lp_next);
3453         g_slice_free (GeePriorityQueueNodePair, self);
3454 }
3455
3456
3457 static gpointer _g_object_ref0 (gpointer self) {
3458         return self ? g_object_ref (self) : NULL;
3459 }
3460
3461
3462 static GeePriorityQueueIterator* gee_priority_queue_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueue* queue) {
3463         GeePriorityQueueIterator * self = NULL;
3464         GeePriorityQueue* _tmp0_;
3465         GeePriorityQueue* _tmp1_;
3466         GeePriorityQueue* _tmp2_;
3467         gint _tmp3_;
3468         g_return_val_if_fail (queue != NULL, NULL);
3469         self = (GeePriorityQueueIterator*) g_object_new (object_type, NULL);
3470         self->priv->g_type = g_type;
3471         self->priv->g_dup_func = g_dup_func;
3472         self->priv->g_destroy_func = g_destroy_func;
3473         _tmp0_ = queue;
3474         _tmp1_ = _g_object_ref0 (_tmp0_);
3475         _g_object_unref0 (self->priv->queue);
3476         self->priv->queue = _tmp1_;
3477         self->priv->position = NULL;
3478         self->priv->previous = NULL;
3479         _tmp2_ = queue;
3480         _tmp3_ = _tmp2_->priv->_stamp;
3481         self->priv->stamp = _tmp3_;
3482         return self;
3483 }
3484
3485
3486 static GeePriorityQueueIterator* gee_priority_queue_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeePriorityQueue* queue) {
3487         return gee_priority_queue_iterator_construct (GEE_PRIORITY_QUEUE_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, queue);
3488 }
3489
3490
3491 static gboolean gee_priority_queue_iterator_real_next (GeeIterator* base) {
3492         GeePriorityQueueIterator * self;
3493         gboolean result = FALSE;
3494         GeePriorityQueueNode* _tmp0_ = NULL;
3495         GeePriorityQueueNode* next;
3496         GeePriorityQueueNode* _tmp1_;
3497         GeePriorityQueueNode* _tmp4_;
3498         self = (GeePriorityQueueIterator*) base;
3499         _tmp0_ = _gee_priority_queue_iterator_get_next_node (self);
3500         next = _tmp0_;
3501         _tmp1_ = next;
3502         if (_tmp1_ != NULL) {
3503                 GeePriorityQueueNode* _tmp2_;
3504                 GeePriorityQueueNode* _tmp3_;
3505                 _tmp2_ = self->priv->position;
3506                 self->priv->previous = _tmp2_;
3507                 _tmp3_ = next;
3508                 self->priv->position = _tmp3_;
3509         }
3510         _tmp4_ = next;
3511         result = _tmp4_ != NULL;
3512         return result;
3513 }
3514
3515
3516 static gboolean gee_priority_queue_iterator_real_has_next (GeeIterator* base) {
3517         GeePriorityQueueIterator * self;
3518         gboolean result = FALSE;
3519         GeePriorityQueueNode* _tmp0_ = NULL;
3520         self = (GeePriorityQueueIterator*) base;
3521         _tmp0_ = _gee_priority_queue_iterator_get_next_node (self);
3522         result = _tmp0_ != NULL;
3523         return result;
3524 }
3525
3526
3527 static inline GeePriorityQueueNode* _gee_priority_queue_iterator_get_next_node (GeePriorityQueueIterator* self) {
3528         GeePriorityQueueNode* result = NULL;
3529         GeePriorityQueueNode* _tmp0_;
3530         g_return_val_if_fail (self != NULL, NULL);
3531         _tmp0_ = self->priv->position;
3532         if (_tmp0_ != NULL) {
3533                 GeePriorityQueueNode* _tmp1_;
3534                 GeePriorityQueueNode* _tmp2_;
3535                 _tmp1_ = self->priv->position;
3536                 _tmp2_ = _tmp1_->iter_next;
3537                 result = _tmp2_;
3538                 return result;
3539         } else {
3540                 GeePriorityQueueNode* _tmp3_ = NULL;
3541                 GeePriorityQueueNode* _tmp4_;
3542                 GeePriorityQueueNode* _tmp9_;
3543                 _tmp4_ = self->priv->previous;
3544                 if (_tmp4_ != NULL) {
3545                         GeePriorityQueueNode* _tmp5_;
3546                         GeePriorityQueueNode* _tmp6_;
3547                         _tmp5_ = self->priv->previous;
3548                         _tmp6_ = _tmp5_->iter_next;
3549                         _tmp3_ = _tmp6_;
3550                 } else {
3551                         GeePriorityQueue* _tmp7_;
3552                         GeePriorityQueueNode* _tmp8_;
3553                         _tmp7_ = self->priv->queue;
3554                         _tmp8_ = _tmp7_->priv->_iter_head;
3555                         _tmp3_ = _tmp8_;
3556                 }
3557                 _tmp9_ = _tmp3_;
3558                 result = _tmp9_;
3559                 return result;
3560         }
3561 }
3562
3563
3564 static gpointer gee_priority_queue_iterator_real_get (GeeIterator* base) {
3565         GeePriorityQueueIterator * self;
3566         gpointer result = NULL;
3567         gint _tmp0_;
3568         GeePriorityQueue* _tmp1_;
3569         gint _tmp2_;
3570         GeePriorityQueueNode* _tmp3_;
3571         GeePriorityQueueNode* _tmp4_;
3572         gconstpointer _tmp5_;
3573         gpointer _tmp6_;
3574         self = (GeePriorityQueueIterator*) base;
3575         _tmp0_ = self->priv->stamp;
3576         _tmp1_ = self->priv->queue;
3577         _tmp2_ = _tmp1_->priv->_stamp;
3578         _vala_assert (_tmp0_ == _tmp2_, "stamp == queue._stamp");
3579         _tmp3_ = self->priv->position;
3580         _vala_assert (_tmp3_ != NULL, "position != null");
3581         _tmp4_ = self->priv->position;
3582         _tmp5_ = _tmp4_->data;
3583         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
3584         result = _tmp6_;
3585         return result;
3586 }
3587
3588
3589 static void gee_priority_queue_iterator_real_remove (GeeIterator* base) {
3590         GeePriorityQueueIterator * self;
3591         gint _tmp0_;
3592         GeePriorityQueue* _tmp1_;
3593         gint _tmp2_;
3594         GeePriorityQueueNode* _tmp3_;
3595         GeePriorityQueueDummyNode* dn = NULL;
3596         GeePriorityQueueNode* _tmp4_;
3597         GeePriorityQueue* _tmp14_;
3598         GeePriorityQueueNode* _tmp15_;
3599         GeePriorityQueueNode* _tmp16_;
3600         GeePriorityQueueDummyNode* _tmp20_;
3601         GeePriorityQueue* _tmp21_;
3602         GeePriorityQueueNode* _tmp22_;
3603         GeePriorityQueueDummyNode* _tmp26_;
3604         GeePriorityQueueNode* _tmp27_;
3605         GeePriorityQueueDummyNode* _tmp31_;
3606         GeePriorityQueue* _tmp32_;
3607         GeePriorityQueueNode* _tmp33_;
3608         gint _tmp36_;
3609         gint _tmp37_;
3610         GeePriorityQueue* _tmp38_;
3611         gint _tmp39_;
3612         self = (GeePriorityQueueIterator*) base;
3613         _tmp0_ = self->priv->stamp;
3614         _tmp1_ = self->priv->queue;
3615         _tmp2_ = _tmp1_->priv->_stamp;
3616         _vala_assert (_tmp0_ == _tmp2_, "stamp == queue._stamp");
3617         _tmp3_ = self->priv->position;
3618         _vala_assert (_tmp3_ != NULL, "position != null");
3619         _tmp4_ = self->priv->previous;
3620         if (_tmp4_ != NULL) {
3621                 GeePriorityQueueNode* _tmp5_;
3622                 GeePriorityQueueNode* _tmp6_;
3623                 GeePriorityQueueNode* _tmp7_;
3624                 GeePriorityQueueNode* _tmp8_;
3625                 GeePriorityQueueDummyNode* _tmp9_;
3626                 _tmp5_ = self->priv->previous;
3627                 _tmp6_ = self->priv->position;
3628                 _tmp7_ = self->priv->previous;
3629                 _tmp8_ = self->priv->position;
3630                 _tmp9_ = gee_priority_queue_dummy_node_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, &_tmp5_->iter_next, &_tmp6_->iter_prev, _tmp7_, _tmp8_);
3631                 _gee_priority_queue_node_unref0 (dn);
3632                 dn = _tmp9_;
3633         } else {
3634                 GeePriorityQueue* _tmp10_;
3635                 GeePriorityQueueNode* _tmp11_;
3636                 GeePriorityQueueNode* _tmp12_;
3637                 GeePriorityQueueDummyNode* _tmp13_;
3638                 _tmp10_ = self->priv->queue;
3639                 _tmp11_ = self->priv->position;
3640                 _tmp12_ = self->priv->position;
3641                 _tmp13_ = gee_priority_queue_dummy_node_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, &_tmp10_->priv->_iter_head, &_tmp11_->iter_prev, NULL, _tmp12_);
3642                 _gee_priority_queue_node_unref0 (dn);
3643                 dn = _tmp13_;
3644         }
3645         _tmp14_ = self->priv->queue;
3646         _tmp15_ = self->priv->position;
3647         _gee_priority_queue_delete (_tmp14_, _tmp15_);
3648         self->priv->position = NULL;
3649         _tmp16_ = self->priv->previous;
3650         if (_tmp16_ != NULL) {
3651                 GeePriorityQueueNode* _tmp17_;
3652                 GeePriorityQueueDummyNode* _tmp18_;
3653                 GeePriorityQueueNode* _tmp19_;
3654                 _tmp17_ = self->priv->previous;
3655                 _tmp18_ = dn;
3656                 _tmp19_ = ((GeePriorityQueueNode*) _tmp18_)->iter_next;
3657                 _tmp17_->iter_next = _tmp19_;
3658         }
3659         _tmp20_ = dn;
3660         _tmp21_ = self->priv->queue;
3661         _tmp22_ = _tmp21_->priv->_iter_head;
3662         if (G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode) == _tmp22_) {
3663                 GeePriorityQueue* _tmp23_;
3664                 GeePriorityQueueDummyNode* _tmp24_;
3665                 GeePriorityQueueNode* _tmp25_;
3666                 _tmp23_ = self->priv->queue;
3667                 _tmp24_ = dn;
3668                 _tmp25_ = ((GeePriorityQueueNode*) _tmp24_)->iter_next;
3669                 _tmp23_->priv->_iter_head = _tmp25_;
3670         }
3671         _tmp26_ = dn;
3672         _tmp27_ = ((GeePriorityQueueNode*) _tmp26_)->iter_next;
3673         if (_tmp27_ != NULL) {
3674                 GeePriorityQueueDummyNode* _tmp28_;
3675                 GeePriorityQueueNode* _tmp29_;
3676                 GeePriorityQueueNode* _tmp30_;
3677                 _tmp28_ = dn;
3678                 _tmp29_ = ((GeePriorityQueueNode*) _tmp28_)->iter_next;
3679                 _tmp30_ = self->priv->previous;
3680                 _tmp29_->iter_prev = _tmp30_;
3681         }
3682         _tmp31_ = dn;
3683         _tmp32_ = self->priv->queue;
3684         _tmp33_ = _tmp32_->priv->_iter_tail;
3685         if (G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, GEE_PRIORITY_QUEUE_TYPE_NODE, GeePriorityQueueNode) == _tmp33_) {
3686                 GeePriorityQueue* _tmp34_;
3687                 GeePriorityQueueNode* _tmp35_;
3688                 _tmp34_ = self->priv->queue;
3689                 _tmp35_ = self->priv->previous;
3690                 _tmp34_->priv->_iter_tail = _tmp35_;
3691         }
3692         _tmp36_ = self->priv->stamp;
3693         self->priv->stamp = _tmp36_ + 1;
3694         _tmp37_ = self->priv->stamp;
3695         _tmp38_ = self->priv->queue;
3696         _tmp39_ = _tmp38_->priv->_stamp;
3697         _vala_assert (_tmp37_ == _tmp39_, "stamp == queue._stamp");
3698         _gee_priority_queue_node_unref0 (dn);
3699 }
3700
3701
3702 static gboolean gee_priority_queue_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
3703         GeePriorityQueueIterator * self;
3704         gboolean result = FALSE;
3705         GeePriorityQueueNode* _tmp0_;
3706         GeeForallFunc _tmp8_;
3707         void* _tmp8__target;
3708         GeePriorityQueueNode* _tmp9_;
3709         gconstpointer _tmp10_;
3710         gpointer _tmp11_;
3711         gboolean _tmp12_ = FALSE;
3712         self = (GeePriorityQueueIterator*) base;
3713         _tmp0_ = self->priv->position;
3714         if (_tmp0_ == NULL) {
3715                 GeePriorityQueueNode* _tmp1_ = NULL;
3716                 GeePriorityQueueNode* _tmp2_;
3717                 GeePriorityQueueNode* _tmp7_;
3718                 _tmp2_ = self->priv->previous;
3719                 if (_tmp2_ != NULL) {
3720                         GeePriorityQueueNode* _tmp3_;
3721                         GeePriorityQueueNode* _tmp4_;
3722                         _tmp3_ = self->priv->previous;
3723                         _tmp4_ = _tmp3_->iter_next;
3724                         _tmp1_ = _tmp4_;
3725                 } else {
3726                         GeePriorityQueue* _tmp5_;
3727                         GeePriorityQueueNode* _tmp6_;
3728                         _tmp5_ = self->priv->queue;
3729                         _tmp6_ = _tmp5_->priv->_iter_head;
3730                         _tmp1_ = _tmp6_;
3731                 }
3732                 _tmp7_ = _tmp1_;
3733                 self->priv->position = _tmp7_;
3734         }
3735         _tmp8_ = f;
3736         _tmp8__target = f_target;
3737         _tmp9_ = self->priv->position;
3738         _tmp10_ = _tmp9_->data;
3739         _tmp11_ = ((_tmp10_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp10_) : ((gpointer) _tmp10_);
3740         _tmp12_ = _tmp8_ (_tmp11_, _tmp8__target);
3741         if (!_tmp12_) {
3742                 result = FALSE;
3743                 return result;
3744         }
3745         while (TRUE) {
3746                 GeePriorityQueueNode* _tmp13_;
3747                 GeePriorityQueueNode* _tmp14_;
3748                 GeePriorityQueueNode* _tmp15_;
3749                 GeePriorityQueueNode* _tmp16_;
3750                 GeePriorityQueueNode* _tmp17_;
3751                 GeeForallFunc _tmp18_;
3752                 void* _tmp18__target;
3753                 GeePriorityQueueNode* _tmp19_;
3754                 gconstpointer _tmp20_;
3755                 gpointer _tmp21_;
3756                 gboolean _tmp22_ = FALSE;
3757                 _tmp13_ = self->priv->position;
3758                 _tmp14_ = _tmp13_->iter_next;
3759                 if (!(_tmp14_ != NULL)) {
3760                         break;
3761                 }
3762                 _tmp15_ = self->priv->position;
3763                 self->priv->previous = _tmp15_;
3764                 _tmp16_ = self->priv->position;
3765                 _tmp17_ = _tmp16_->iter_next;
3766                 self->priv->position = _tmp17_;
3767                 _tmp18_ = f;
3768                 _tmp18__target = f_target;
3769                 _tmp19_ = self->priv->position;
3770                 _tmp20_ = _tmp19_->data;
3771                 _tmp21_ = ((_tmp20_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp20_) : ((gpointer) _tmp20_);
3772                 _tmp22_ = _tmp18_ (_tmp21_, _tmp18__target);
3773                 if (!_tmp22_) {
3774                         result = FALSE;
3775                         return result;
3776                 }
3777         }
3778         result = TRUE;
3779         return result;
3780 }
3781
3782
3783 static gboolean gee_priority_queue_iterator_real_get_read_only (GeeIterator* base) {
3784         gboolean result;
3785         GeePriorityQueueIterator* self;
3786         self = (GeePriorityQueueIterator*) base;
3787         result = FALSE;
3788         return result;
3789 }
3790
3791
3792 static gboolean gee_priority_queue_iterator_real_get_valid (GeeIterator* base) {
3793         gboolean result;
3794         GeePriorityQueueIterator* self;
3795         GeePriorityQueueNode* _tmp0_;
3796         self = (GeePriorityQueueIterator*) base;
3797         _tmp0_ = self->priv->position;
3798         result = _tmp0_ != NULL;
3799         return result;
3800 }
3801
3802
3803 static void gee_priority_queue_iterator_class_init (GeePriorityQueueIteratorClass * klass) {
3804         gee_priority_queue_iterator_parent_class = g_type_class_peek_parent (klass);
3805         g_type_class_add_private (klass, sizeof (GeePriorityQueueIteratorPrivate));
3806         G_OBJECT_CLASS (klass)->get_property = _vala_gee_priority_queue_iterator_get_property;
3807         G_OBJECT_CLASS (klass)->set_property = _vala_gee_priority_queue_iterator_set_property;
3808         G_OBJECT_CLASS (klass)->finalize = gee_priority_queue_iterator_finalize;
3809         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3810         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3811         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3812         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_ITERATOR_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
3813         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_ITERATOR_VALID, g_param_spec_boolean ("valid", "valid", "valid", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
3814 }
3815
3816
3817 static GType gee_priority_queue_iterator_gee_traversable_get_g_type (GeePriorityQueueIterator* self) {
3818         return self->priv->g_type;
3819 }
3820
3821
3822 static GBoxedCopyFunc gee_priority_queue_iterator_gee_traversable_get_g_dup_func (GeePriorityQueueIterator* self) {
3823         return self->priv->g_dup_func;
3824 }
3825
3826
3827 static GDestroyNotify gee_priority_queue_iterator_gee_traversable_get_g_destroy_func (GeePriorityQueueIterator* self) {
3828         return self->priv->g_destroy_func;
3829 }
3830
3831
3832 static void gee_priority_queue_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
3833         gee_priority_queue_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
3834         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_priority_queue_iterator_real_foreach;
3835         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_priority_queue_iterator_gee_traversable_get_g_type;
3836         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_priority_queue_iterator_gee_traversable_get_g_dup_func;
3837         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_priority_queue_iterator_gee_traversable_get_g_destroy_func;
3838 }
3839
3840
3841 static void gee_priority_queue_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
3842         gee_priority_queue_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
3843         iface->next = (gboolean (*)(GeeIterator*)) gee_priority_queue_iterator_real_next;
3844         iface->has_next = (gboolean (*)(GeeIterator*)) gee_priority_queue_iterator_real_has_next;
3845         iface->get = (gpointer (*)(GeeIterator*)) gee_priority_queue_iterator_real_get;
3846         iface->remove = (void (*)(GeeIterator*)) gee_priority_queue_iterator_real_remove;
3847         iface->get_read_only = gee_priority_queue_iterator_real_get_read_only;
3848         iface->get_valid = gee_priority_queue_iterator_real_get_valid;
3849 }
3850
3851
3852 static void gee_priority_queue_iterator_instance_init (GeePriorityQueueIterator * self) {
3853         self->priv = GEE_PRIORITY_QUEUE_ITERATOR_GET_PRIVATE (self);
3854 }
3855
3856
3857 static void gee_priority_queue_iterator_finalize (GObject* obj) {
3858         GeePriorityQueueIterator * self;
3859         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_PRIORITY_QUEUE_TYPE_ITERATOR, GeePriorityQueueIterator);
3860         _g_object_unref0 (self->priv->queue);
3861         G_OBJECT_CLASS (gee_priority_queue_iterator_parent_class)->finalize (obj);
3862 }
3863
3864
3865 static GType gee_priority_queue_iterator_get_type (void) {
3866         static volatile gsize gee_priority_queue_iterator_type_id__volatile = 0;
3867         if (g_once_init_enter (&gee_priority_queue_iterator_type_id__volatile)) {
3868                 static const GTypeInfo g_define_type_info = { sizeof (GeePriorityQueueIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_priority_queue_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePriorityQueueIterator), 0, (GInstanceInitFunc) gee_priority_queue_iterator_instance_init, NULL };
3869                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_priority_queue_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3870                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_priority_queue_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3871                 GType gee_priority_queue_iterator_type_id;
3872                 gee_priority_queue_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeePriorityQueueIterator", &g_define_type_info, 0);
3873                 g_type_add_interface_static (gee_priority_queue_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
3874                 g_type_add_interface_static (gee_priority_queue_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
3875                 g_once_init_leave (&gee_priority_queue_iterator_type_id__volatile, gee_priority_queue_iterator_type_id);
3876         }
3877         return gee_priority_queue_iterator_type_id__volatile;
3878 }
3879
3880
3881 static void _vala_gee_priority_queue_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
3882         GeePriorityQueueIterator * self;
3883         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_PRIORITY_QUEUE_TYPE_ITERATOR, GeePriorityQueueIterator);
3884         switch (property_id) {
3885                 case GEE_PRIORITY_QUEUE_ITERATOR_READ_ONLY:
3886                 g_value_set_boolean (value, gee_iterator_get_read_only ((GeeIterator*) self));
3887                 break;
3888                 case GEE_PRIORITY_QUEUE_ITERATOR_VALID:
3889                 g_value_set_boolean (value, gee_iterator_get_valid ((GeeIterator*) self));
3890                 break;
3891                 default:
3892                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3893                 break;
3894         }
3895 }
3896
3897
3898 static void _vala_gee_priority_queue_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3899         GeePriorityQueueIterator * self;
3900         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_PRIORITY_QUEUE_TYPE_ITERATOR, GeePriorityQueueIterator);
3901         switch (property_id) {
3902                 case GEE_PRIORITY_QUEUE_ITERATOR_G_TYPE:
3903                 self->priv->g_type = g_value_get_gtype (value);
3904                 break;
3905                 case GEE_PRIORITY_QUEUE_ITERATOR_G_DUP_FUNC:
3906                 self->priv->g_dup_func = g_value_get_pointer (value);
3907                 break;
3908                 case GEE_PRIORITY_QUEUE_ITERATOR_G_DESTROY_FUNC:
3909                 self->priv->g_destroy_func = g_value_get_pointer (value);
3910                 break;
3911                 default:
3912                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3913                 break;
3914         }
3915 }
3916
3917
3918 static void gee_priority_queue_class_init (GeePriorityQueueClass * klass) {
3919         gee_priority_queue_parent_class = g_type_class_peek_parent (klass);
3920         g_type_class_add_private (klass, sizeof (GeePriorityQueuePrivate));
3921         GEE_ABSTRACT_QUEUE_CLASS (klass)->peek = gee_priority_queue_real_peek;
3922         GEE_ABSTRACT_QUEUE_CLASS (klass)->poll = gee_priority_queue_real_poll;
3923         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_priority_queue_real_contains;
3924         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_priority_queue_real_add;
3925         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_priority_queue_real_remove;
3926         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_priority_queue_real_clear;
3927         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_priority_queue_real_iterator;
3928         GEE_ABSTRACT_QUEUE_CLASS (klass)->get_capacity = gee_priority_queue_real_get_capacity;
3929         GEE_ABSTRACT_QUEUE_CLASS (klass)->get_remaining_capacity = gee_priority_queue_real_get_remaining_capacity;
3930         GEE_ABSTRACT_QUEUE_CLASS (klass)->get_is_full = gee_priority_queue_real_get_is_full;
3931         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_priority_queue_real_get_read_only;
3932         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_priority_queue_real_get_size;
3933         G_OBJECT_CLASS (klass)->get_property = _vala_gee_priority_queue_get_property;
3934         G_OBJECT_CLASS (klass)->set_property = _vala_gee_priority_queue_set_property;
3935         G_OBJECT_CLASS (klass)->finalize = gee_priority_queue_finalize;
3936         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3937         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3938         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3939         /**
3940          * {@inheritDoc}
3941          */
3942         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3943         /**
3944          * {@inheritDoc}
3945          */
3946         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3947         /**
3948          * {@inheritDoc}
3949          */
3950         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3951         /**
3952          * {@inheritDoc}
3953          */
3954         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
3955         /**
3956          * {@inheritDoc}
3957          */
3958         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_PRIORITY_QUEUE_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));
3959 }
3960
3961
3962 static void gee_priority_queue_instance_init (GeePriorityQueue * self) {
3963         GeePriorityQueueType1Node** _tmp0_ = NULL;
3964         gboolean* _tmp1_ = NULL;
3965         self->priv = GEE_PRIORITY_QUEUE_GET_PRIVATE (self);
3966         self->priv->_size = 0;
3967         self->priv->_stamp = 0;
3968         self->priv->_r = NULL;
3969         self->priv->_r_prime = NULL;
3970         self->priv->_lm_head = NULL;
3971         self->priv->_lm_tail = NULL;
3972         self->priv->_p = NULL;
3973         _tmp0_ = g_new0 (GeePriorityQueueType1Node*, 0 + 1);
3974         self->priv->_a = _tmp0_;
3975         self->priv->_a_length1 = 0;
3976         self->priv->__a_size_ = self->priv->_a_length1;
3977         self->priv->_lp_head = NULL;
3978         self->priv->_lp_tail = NULL;
3979         _tmp1_ = g_new0 (gboolean, 0);
3980         self->priv->_b = _tmp1_;
3981         self->priv->_b_length1 = 0;
3982         self->priv->__b_size_ = self->priv->_b_length1;
3983         self->priv->_ll_head = NULL;
3984         self->priv->_ll_tail = NULL;
3985         self->priv->_iter_head = NULL;
3986         self->priv->_iter_tail = NULL;
3987 }
3988
3989
3990 static void gee_priority_queue_finalize (GObject* obj) {
3991         GeePriorityQueue * self;
3992         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_PRIORITY_QUEUE, GeePriorityQueue);
3993         (self->priv->_compare_func_target_destroy_notify == NULL) ? NULL : (self->priv->_compare_func_target_destroy_notify (self->priv->_compare_func_target), NULL);
3994         self->priv->_compare_func = NULL;
3995         self->priv->_compare_func_target = NULL;
3996         self->priv->_compare_func_target_destroy_notify = NULL;
3997         _gee_priority_queue_node_unref0 (self->priv->_r);
3998         _gee_priority_queue_node_unref0 (self->priv->_r_prime);
3999         _gee_priority_queue_node_unref0 (self->priv->_lm_head);
4000         _gee_priority_queue_node_unref0 (self->priv->_lm_tail);
4001         _gee_priority_queue_node_unref0 (self->priv->_p);
4002         self->priv->_a = (_vala_array_free (self->priv->_a, self->priv->_a_length1, (GDestroyNotify) gee_priority_queue_node_unref), NULL);
4003         _gee_priority_queue_node_pair_free0 (self->priv->_lp_head);
4004         self->priv->_b = (g_free (self->priv->_b), NULL);
4005         _gee_priority_queue_node_unref0 (self->priv->_ll_head);
4006         _gee_priority_queue_node_unref0 (self->priv->_ll_tail);
4007         G_OBJECT_CLASS (gee_priority_queue_parent_class)->finalize (obj);
4008 }
4009
4010
4011 /**
4012  * Relaxed fibonacci heap priority queue implementation of the {@link Queue}.
4013  *
4014  * The elements of the priority queue are ordered according to their natural
4015  * ordering, or by a compare_func provided at queue construction time. A
4016  * priority queue does not permit null elements and does not have bounded
4017  * capacity.
4018  *
4019  * This implementation provides O(1) time for offer and peek methods, and
4020  * O(log n) for poll method. It is based on the algorithms described by
4021  * Boyapati Chandra Sekhar in:
4022  *
4023  *   "Worst Case Efficient Data Structures
4024  *      for Priority Queues and Deques with Heap Order"
4025  *   Boyapati Chandra Sekhar (under the guidance of Prof. C. Pandu Rangan)
4026  *   Department of Computer Science and Engineering
4027  *   Indian Institute of Technology, Madras
4028  *   May 1996
4029  */
4030 GType gee_priority_queue_get_type (void) {
4031         static volatile gsize gee_priority_queue_type_id__volatile = 0;
4032         if (g_once_init_enter (&gee_priority_queue_type_id__volatile)) {
4033                 static const GTypeInfo g_define_type_info = { sizeof (GeePriorityQueueClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_priority_queue_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeePriorityQueue), 0, (GInstanceInitFunc) gee_priority_queue_instance_init, NULL };
4034                 GType gee_priority_queue_type_id;
4035                 gee_priority_queue_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_QUEUE, "GeePriorityQueue", &g_define_type_info, 0);
4036                 g_once_init_leave (&gee_priority_queue_type_id__volatile, gee_priority_queue_type_id);
4037         }
4038         return gee_priority_queue_type_id__volatile;
4039 }
4040
4041
4042 static void _vala_gee_priority_queue_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
4043         GeePriorityQueue * self;
4044         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_PRIORITY_QUEUE, GeePriorityQueue);
4045         switch (property_id) {
4046                 case GEE_PRIORITY_QUEUE_CAPACITY:
4047                 g_value_set_int (value, gee_abstract_queue_get_capacity ((GeeAbstractQueue*) self));
4048                 break;
4049                 case GEE_PRIORITY_QUEUE_REMAINING_CAPACITY:
4050                 g_value_set_int (value, gee_abstract_queue_get_remaining_capacity ((GeeAbstractQueue*) self));
4051                 break;
4052                 case GEE_PRIORITY_QUEUE_IS_FULL:
4053                 g_value_set_boolean (value, gee_abstract_queue_get_is_full ((GeeAbstractQueue*) self));
4054                 break;
4055                 case GEE_PRIORITY_QUEUE_READ_ONLY:
4056                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
4057                 break;
4058                 case GEE_PRIORITY_QUEUE_SIZE:
4059                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
4060                 break;
4061                 default:
4062                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4063                 break;
4064         }
4065 }
4066
4067
4068 static void _vala_gee_priority_queue_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
4069         GeePriorityQueue * self;
4070         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_PRIORITY_QUEUE, GeePriorityQueue);
4071         switch (property_id) {
4072                 case GEE_PRIORITY_QUEUE_G_TYPE:
4073                 self->priv->g_type = g_value_get_gtype (value);
4074                 break;
4075                 case GEE_PRIORITY_QUEUE_G_DUP_FUNC:
4076                 self->priv->g_dup_func = g_value_get_pointer (value);
4077                 break;
4078                 case GEE_PRIORITY_QUEUE_G_DESTROY_FUNC:
4079                 self->priv->g_destroy_func = g_value_get_pointer (value);
4080                 break;
4081                 default:
4082                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4083                 break;
4084         }
4085 }
4086
4087
4088 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
4089         if ((array != NULL) && (destroy_func != NULL)) {
4090                 int i;
4091                 for (i = 0; i < array_length; i = i + 1) {
4092                         if (((gpointer*) array)[i] != NULL) {
4093                                 destroy_func (((gpointer*) array)[i]);
4094                         }
4095                 }
4096         }
4097 }
4098
4099
4100 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
4101         _vala_array_destroy (array, array_length, destroy_func);
4102         g_free (array);
4103 }
4104
4105
4106