gee/hashmap.c

   1 /* hashmap.c generated by valac 0.18.0, the Vala compiler
   2  * generated from hashmap.vala, do not modify */
   3
   4 /* hashmap.vala
   5  *
   6  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   7  * Copyright (C) 1997-2000  GLib Team and others
   8  * Copyright (C) 2007-2009  Jürg Billeter
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  23  *
  24  * Author:
  25  *      Jürg Billeter <j@bitron.ch>
  26  */
  27
  28 #include <glib.h>
  29 #include <glib-object.h>
  30
  31
  32 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  33 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  34 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  35 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  36
  37 typedef struct _GeeTraversable GeeTraversable;
  38 typedef struct _GeeTraversableIface GeeTraversableIface;
  39
  40 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  41
  42 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  43 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  44 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  45 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  46 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  47 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  48
  49 typedef struct _GeeLazy GeeLazy;
  50 typedef struct _GeeLazyClass GeeLazyClass;
  51
  52 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  53 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  54 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  55 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  56
  57 typedef struct _GeeIterator GeeIterator;
  58 typedef struct _GeeIteratorIface GeeIteratorIface;
  59
  60 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  61 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  62 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  63 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  64
  65 typedef struct _GeeIterable GeeIterable;
  66 typedef struct _GeeIterableIface GeeIterableIface;
  67
  68 #define GEE_TYPE_MAP (gee_map_get_type ())
  69 #define GEE_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP, GeeMap))
  70 #define GEE_IS_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP))
  71 #define GEE_MAP_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP, GeeMapIface))
  72
  73 typedef struct _GeeMap GeeMap;
  74 typedef struct _GeeMapIface GeeMapIface;
  75
  76 #define GEE_TYPE_MAP_ITERATOR (gee_map_iterator_get_type ())
  77 #define GEE_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIterator))
  78 #define GEE_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP_ITERATOR))
  79 #define GEE_MAP_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIteratorIface))
  80
  81 typedef struct _GeeMapIterator GeeMapIterator;
  82 typedef struct _GeeMapIteratorIface GeeMapIteratorIface;
  83
  84 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  85 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  86 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  87 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  88
  89 typedef struct _GeeCollection GeeCollection;
  90 typedef struct _GeeCollectionIface GeeCollectionIface;
  91
  92 #define GEE_TYPE_SET (gee_set_get_type ())
  93 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
  94 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
  95 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
  96
  97 typedef struct _GeeSet GeeSet;
  98 typedef struct _GeeSetIface GeeSetIface;
  99
 100 #define GEE_MAP_TYPE_ENTRY (gee_map_entry_get_type ())
 101 #define GEE_MAP_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntry))
 102 #define GEE_MAP_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 103 #define GEE_MAP_IS_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_MAP_TYPE_ENTRY))
 104 #define GEE_MAP_IS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_MAP_TYPE_ENTRY))
 105 #define GEE_MAP_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 106
 107 typedef struct _GeeMapEntry GeeMapEntry;
 108 typedef struct _GeeMapEntryClass GeeMapEntryClass;
 109
 110 #define GEE_TYPE_ABSTRACT_MAP (gee_abstract_map_get_type ())
 111 #define GEE_ABSTRACT_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_MAP, GeeAbstractMap))
 112 #define GEE_ABSTRACT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_MAP, GeeAbstractMapClass))
 113 #define GEE_IS_ABSTRACT_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_MAP))
 114 #define GEE_IS_ABSTRACT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_MAP))
 115 #define GEE_ABSTRACT_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_MAP, GeeAbstractMapClass))
 116
 117 typedef struct _GeeAbstractMap GeeAbstractMap;
 118 typedef struct _GeeAbstractMapClass GeeAbstractMapClass;
 119 typedef struct _GeeAbstractMapPrivate GeeAbstractMapPrivate;
 120
 121 #define GEE_TYPE_HASH_MAP (gee_hash_map_get_type ())
 122 #define GEE_HASH_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_HASH_MAP, GeeHashMap))
 123 #define GEE_HASH_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_HASH_MAP, GeeHashMapClass))
 124 #define GEE_IS_HASH_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_HASH_MAP))
 125 #define GEE_IS_HASH_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_HASH_MAP))
 126 #define GEE_HASH_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_HASH_MAP, GeeHashMapClass))
 127
 128 typedef struct _GeeHashMap GeeHashMap;
 129 typedef struct _GeeHashMapClass GeeHashMapClass;
 130 typedef struct _GeeHashMapPrivate GeeHashMapPrivate;
 131 typedef struct _GeeHashMapNode GeeHashMapNode;
 132 #define _gee_hash_map_node_free0(var) ((var == NULL) ? NULL : (var = (gee_hash_map_node_free (var), NULL)))
 133
 134 #define GEE_HASH_MAP_TYPE_NODE_ITERATOR (gee_hash_map_node_iterator_get_type ())
 135 #define GEE_HASH_MAP_NODE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_NODE_ITERATOR, GeeHashMapNodeIterator))
 136 #define GEE_HASH_MAP_NODE_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_NODE_ITERATOR, GeeHashMapNodeIteratorClass))
 137 #define GEE_HASH_MAP_IS_NODE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_NODE_ITERATOR))
 138 #define GEE_HASH_MAP_IS_NODE_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_NODE_ITERATOR))
 139 #define GEE_HASH_MAP_NODE_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_NODE_ITERATOR, GeeHashMapNodeIteratorClass))
 140
 141 typedef struct _GeeHashMapNodeIterator GeeHashMapNodeIterator;
 142 typedef struct _GeeHashMapNodeIteratorClass GeeHashMapNodeIteratorClass;
 143
 144 #define GEE_HASH_MAP_TYPE_MAP_ITERATOR (gee_hash_map_map_iterator_get_type ())
 145 #define GEE_HASH_MAP_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_MAP_ITERATOR, GeeHashMapMapIterator))
 146 #define GEE_HASH_MAP_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_MAP_ITERATOR, GeeHashMapMapIteratorClass))
 147 #define GEE_HASH_MAP_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_MAP_ITERATOR))
 148 #define GEE_HASH_MAP_IS_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_MAP_ITERATOR))
 149 #define GEE_HASH_MAP_MAP_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_MAP_ITERATOR, GeeHashMapMapIteratorClass))
 150
 151 typedef struct _GeeHashMapMapIterator GeeHashMapMapIterator;
 152 typedef struct _GeeHashMapMapIteratorClass GeeHashMapMapIteratorClass;
 153
 154 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
 155 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
 156 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
 157 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
 158 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
 159 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
 160
 161 typedef struct _GeeAbstractCollection GeeAbstractCollection;
 162 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
 163
 164 #define GEE_TYPE_ABSTRACT_SET (gee_abstract_set_get_type ())
 165 #define GEE_ABSTRACT_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_SET, GeeAbstractSet))
 166 #define GEE_ABSTRACT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_SET, GeeAbstractSetClass))
 167 #define GEE_IS_ABSTRACT_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_SET))
 168 #define GEE_IS_ABSTRACT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_SET))
 169 #define GEE_ABSTRACT_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_SET, GeeAbstractSetClass))
 170
 171 typedef struct _GeeAbstractSet GeeAbstractSet;
 172 typedef struct _GeeAbstractSetClass GeeAbstractSetClass;
 173
 174 #define GEE_HASH_MAP_TYPE_KEY_SET (gee_hash_map_key_set_get_type ())
 175 #define GEE_HASH_MAP_KEY_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_KEY_SET, GeeHashMapKeySet))
 176 #define GEE_HASH_MAP_KEY_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_KEY_SET, GeeHashMapKeySetClass))
 177 #define GEE_HASH_MAP_IS_KEY_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_KEY_SET))
 178 #define GEE_HASH_MAP_IS_KEY_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_KEY_SET))
 179 #define GEE_HASH_MAP_KEY_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_KEY_SET, GeeHashMapKeySetClass))
 180
 181 typedef struct _GeeHashMapKeySet GeeHashMapKeySet;
 182 typedef struct _GeeHashMapKeySetClass GeeHashMapKeySetClass;
 183 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 184
 185 #define GEE_HASH_MAP_TYPE_VALUE_COLLECTION (gee_hash_map_value_collection_get_type ())
 186 #define GEE_HASH_MAP_VALUE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_VALUE_COLLECTION, GeeHashMapValueCollection))
 187 #define GEE_HASH_MAP_VALUE_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_VALUE_COLLECTION, GeeHashMapValueCollectionClass))
 188 #define GEE_HASH_MAP_IS_VALUE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_VALUE_COLLECTION))
 189 #define GEE_HASH_MAP_IS_VALUE_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_VALUE_COLLECTION))
 190 #define GEE_HASH_MAP_VALUE_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_VALUE_COLLECTION, GeeHashMapValueCollectionClass))
 191
 192 typedef struct _GeeHashMapValueCollection GeeHashMapValueCollection;
 193 typedef struct _GeeHashMapValueCollectionClass GeeHashMapValueCollectionClass;
 194
 195 #define GEE_HASH_MAP_TYPE_ENTRY_SET (gee_hash_map_entry_set_get_type ())
 196 #define GEE_HASH_MAP_ENTRY_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_ENTRY_SET, GeeHashMapEntrySet))
 197 #define GEE_HASH_MAP_ENTRY_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_ENTRY_SET, GeeHashMapEntrySetClass))
 198 #define GEE_HASH_MAP_IS_ENTRY_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_ENTRY_SET))
 199 #define GEE_HASH_MAP_IS_ENTRY_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_ENTRY_SET))
 200 #define GEE_HASH_MAP_ENTRY_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_ENTRY_SET, GeeHashMapEntrySetClass))
 201
 202 typedef struct _GeeHashMapEntrySet GeeHashMapEntrySet;
 203 typedef struct _GeeHashMapEntrySetClass GeeHashMapEntrySetClass;
 204 typedef struct _GeeMapEntryPrivate GeeMapEntryPrivate;
 205
 206 #define GEE_HASH_MAP_TYPE_ENTRY (gee_hash_map_entry_get_type ())
 207 #define GEE_HASH_MAP_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_ENTRY, GeeHashMapEntry))
 208 #define GEE_HASH_MAP_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_ENTRY, GeeHashMapEntryClass))
 209 #define GEE_HASH_MAP_IS_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_ENTRY))
 210 #define GEE_HASH_MAP_IS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_ENTRY))
 211 #define GEE_HASH_MAP_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_ENTRY, GeeHashMapEntryClass))
 212
 213 typedef struct _GeeHashMapEntry GeeHashMapEntry;
 214 typedef struct _GeeHashMapEntryClass GeeHashMapEntryClass;
 215 typedef struct _GeeHashMapEntryPrivate GeeHashMapEntryPrivate;
 216 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
 217 typedef struct _GeeAbstractSetPrivate GeeAbstractSetPrivate;
 218 typedef struct _GeeHashMapKeySetPrivate GeeHashMapKeySetPrivate;
 219
 220 #define GEE_HASH_MAP_TYPE_KEY_ITERATOR (gee_hash_map_key_iterator_get_type ())
 221 #define GEE_HASH_MAP_KEY_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_KEY_ITERATOR, GeeHashMapKeyIterator))
 222 #define GEE_HASH_MAP_KEY_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_KEY_ITERATOR, GeeHashMapKeyIteratorClass))
 223 #define GEE_HASH_MAP_IS_KEY_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_KEY_ITERATOR))
 224 #define GEE_HASH_MAP_IS_KEY_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_KEY_ITERATOR))
 225 #define GEE_HASH_MAP_KEY_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_KEY_ITERATOR, GeeHashMapKeyIteratorClass))
 226
 227 typedef struct _GeeHashMapKeyIterator GeeHashMapKeyIterator;
 228 typedef struct _GeeHashMapKeyIteratorClass GeeHashMapKeyIteratorClass;
 229 typedef struct _GeeHashMapValueCollectionPrivate GeeHashMapValueCollectionPrivate;
 230
 231 #define GEE_HASH_MAP_TYPE_VALUE_ITERATOR (gee_hash_map_value_iterator_get_type ())
 232 #define GEE_HASH_MAP_VALUE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_VALUE_ITERATOR, GeeHashMapValueIterator))
 233 #define GEE_HASH_MAP_VALUE_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_VALUE_ITERATOR, GeeHashMapValueIteratorClass))
 234 #define GEE_HASH_MAP_IS_VALUE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_VALUE_ITERATOR))
 235 #define GEE_HASH_MAP_IS_VALUE_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_VALUE_ITERATOR))
 236 #define GEE_HASH_MAP_VALUE_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_VALUE_ITERATOR, GeeHashMapValueIteratorClass))
 237
 238 typedef struct _GeeHashMapValueIterator GeeHashMapValueIterator;
 239 typedef struct _GeeHashMapValueIteratorClass GeeHashMapValueIteratorClass;
 240 typedef struct _GeeHashMapEntrySetPrivate GeeHashMapEntrySetPrivate;
 241
 242 #define GEE_HASH_MAP_TYPE_ENTRY_ITERATOR (gee_hash_map_entry_iterator_get_type ())
 243 #define GEE_HASH_MAP_ENTRY_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_HASH_MAP_TYPE_ENTRY_ITERATOR, GeeHashMapEntryIterator))
 244 #define GEE_HASH_MAP_ENTRY_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_HASH_MAP_TYPE_ENTRY_ITERATOR, GeeHashMapEntryIteratorClass))
 245 #define GEE_HASH_MAP_IS_ENTRY_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_HASH_MAP_TYPE_ENTRY_ITERATOR))
 246 #define GEE_HASH_MAP_IS_ENTRY_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_HASH_MAP_TYPE_ENTRY_ITERATOR))
 247 #define GEE_HASH_MAP_ENTRY_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_HASH_MAP_TYPE_ENTRY_ITERATOR, GeeHashMapEntryIteratorClass))
 248
 249 typedef struct _GeeHashMapEntryIterator GeeHashMapEntryIterator;
 250 typedef struct _GeeHashMapEntryIteratorClass GeeHashMapEntryIteratorClass;
 251 typedef struct _GeeHashMapNodeIteratorPrivate GeeHashMapNodeIteratorPrivate;
 252 typedef struct _GeeHashMapKeyIteratorPrivate GeeHashMapKeyIteratorPrivate;
 253 typedef struct _GeeHashMapMapIteratorPrivate GeeHashMapMapIteratorPrivate;
 254 typedef struct _GeeHashMapValueIteratorPrivate GeeHashMapValueIteratorPrivate;
 255 typedef struct _GeeHashMapEntryIteratorPrivate GeeHashMapEntryIteratorPrivate;
 256 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 257
 258 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 259 typedef enum  {
 260         GEE_TRAVERSABLE_STREAM_YIELD,
 261         GEE_TRAVERSABLE_STREAM_CONTINUE,
 262         GEE_TRAVERSABLE_STREAM_END
 263 } GeeTraversableStream;
 264
 265 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 266 struct _GeeIteratorIface {
 267         GTypeInterface parent_iface;
 268         gboolean (*next) (GeeIterator* self);
 269         gboolean (*has_next) (GeeIterator* self);
 270         gpointer (*get) (GeeIterator* self);
 271         void (*remove) (GeeIterator* self);
 272         gboolean (*get_valid) (GeeIterator* self);
 273         gboolean (*get_read_only) (GeeIterator* self);
 274 };
 275
 276 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 277 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 278 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 279 struct _GeeTraversableIface {
 280         GTypeInterface parent_iface;
 281         GType (*get_g_type) (GeeTraversable* self);
 282         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 283         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 284         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 285         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);
 286         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 287         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 288         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 289         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 290         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 291         GType (*get_element_type) (GeeTraversable* self);
 292 };
 293
 294 struct _GeeIterableIface {
 295         GTypeInterface parent_iface;
 296         GType (*get_g_type) (GeeIterable* self);
 297         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 298         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 299         GeeIterator* (*iterator) (GeeIterable* self);
 300 };
 301
 302 typedef gpointer (*GeeFoldMapFunc) (gconstpointer k, gconstpointer v, gpointer a, void* user_data);
 303 typedef gboolean (*GeeForallMapFunc) (gconstpointer k, gconstpointer v, void* user_data);
 304 struct _GeeMapIteratorIface {
 305         GTypeInterface parent_iface;
 306         GType (*get_k_type) (GeeMapIterator* self);
 307         GBoxedCopyFunc (*get_k_dup_func) (GeeMapIterator* self);
 308         GDestroyNotify (*get_k_destroy_func) (GeeMapIterator* self);
 309         GType (*get_v_type) (GeeMapIterator* self);
 310         GBoxedCopyFunc (*get_v_dup_func) (GeeMapIterator* self);
 311         GDestroyNotify (*get_v_destroy_func) (GeeMapIterator* self);
 312         gboolean (*next) (GeeMapIterator* self);
 313         gboolean (*has_next) (GeeMapIterator* self);
 314         gpointer (*get_key) (GeeMapIterator* self);
 315         gpointer (*get_value) (GeeMapIterator* self);
 316         void (*set_value) (GeeMapIterator* self, gconstpointer value);
 317         void (*unset) (GeeMapIterator* self);
 318         gpointer (*fold) (GeeMapIterator* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldMapFunc f, void* f_target, gpointer seed);
 319         gboolean (*foreach) (GeeMapIterator* self, GeeForallMapFunc f, void* f_target);
 320         gboolean (*get_valid) (GeeMapIterator* self);
 321         gboolean (*get_mutable) (GeeMapIterator* self);
 322         gboolean (*get_read_only) (GeeMapIterator* self);
 323 };
 324
 325 struct _GeeCollectionIface {
 326         GTypeInterface parent_iface;
 327         GType (*get_g_type) (GeeCollection* self);
 328         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 329         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 330         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 331         gboolean (*add) (GeeCollection* self, gconstpointer item);
 332         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 333         void (*clear) (GeeCollection* self);
 334         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 335         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 336         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 337         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 338         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 339         gint (*get_size) (GeeCollection* self);
 340         gboolean (*get_is_empty) (GeeCollection* self);
 341         gboolean (*get_read_only) (GeeCollection* self);
 342         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 343 };
 344
 345 struct _GeeSetIface {
 346         GTypeInterface parent_iface;
 347         GType (*get_g_type) (GeeSet* self);
 348         GBoxedCopyFunc (*get_g_dup_func) (GeeSet* self);
 349         GDestroyNotify (*get_g_destroy_func) (GeeSet* self);
 350         GeeSet* (*get_read_only_view) (GeeSet* self);
 351 };
 352
 353 struct _GeeMapIface {
 354         GTypeInterface parent_iface;
 355         GType (*get_k_type) (GeeMap* self);
 356         GBoxedCopyFunc (*get_k_dup_func) (GeeMap* self);
 357         GDestroyNotify (*get_k_destroy_func) (GeeMap* self);
 358         GType (*get_v_type) (GeeMap* self);
 359         GBoxedCopyFunc (*get_v_dup_func) (GeeMap* self);
 360         GDestroyNotify (*get_v_destroy_func) (GeeMap* self);
 361         gboolean (*has_key) (GeeMap* self, gconstpointer key);
 362         gboolean (*has) (GeeMap* self, gconstpointer key, gconstpointer value);
 363         gpointer (*get) (GeeMap* self, gconstpointer key);
 364         void (*set) (GeeMap* self, gconstpointer key, gconstpointer value);
 365         gboolean (*unset) (GeeMap* self, gconstpointer key, gpointer* value);
 366         void (*clear) (GeeMap* self);
 367         GeeMapIterator* (*map_iterator) (GeeMap* self);
 368         void (*set_all) (GeeMap* self, GeeMap* map);
 369         gboolean (*unset_all) (GeeMap* self, GeeMap* map);
 370         gboolean (*has_all) (GeeMap* self, GeeMap* map);
 371         gint (*get_size) (GeeMap* self);
 372         gboolean (*get_is_empty) (GeeMap* self);
 373         gboolean (*get_read_only) (GeeMap* self);
 374         GeeSet* (*get_keys) (GeeMap* self);
 375         GeeCollection* (*get_values) (GeeMap* self);
 376         GeeSet* (*get_entries) (GeeMap* self);
 377         GeeMap* (*get_read_only_view) (GeeMap* self);
 378 };
 379
 380 struct _GeeAbstractMap {
 381         GObject parent_instance;
 382         GeeAbstractMapPrivate * priv;
 383 };
 384
 385 struct _GeeAbstractMapClass {
 386         GObjectClass parent_class;
 387         gboolean (*has_key) (GeeAbstractMap* self, gconstpointer key);
 388         gboolean (*has) (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 389         gpointer (*get) (GeeAbstractMap* self, gconstpointer key);
 390         void (*set) (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 391         gboolean (*unset) (GeeAbstractMap* self, gconstpointer key, gpointer* value);
 392         GeeMapIterator* (*map_iterator) (GeeAbstractMap* self);
 393         void (*clear) (GeeAbstractMap* self);
 394         gboolean (*foreach) (GeeAbstractMap* self, GeeForallFunc f, void* f_target);
 395         GeeIterator* (*stream) (GeeAbstractMap* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 396         void (*reserved0) (GeeAbstractMap* self);
 397         void (*reserved1) (GeeAbstractMap* self);
 398         void (*reserved2) (GeeAbstractMap* self);
 399         void (*reserved3) (GeeAbstractMap* self);
 400         void (*reserved4) (GeeAbstractMap* self);
 401         void (*reserved5) (GeeAbstractMap* self);
 402         void (*reserved6) (GeeAbstractMap* self);
 403         void (*reserved7) (GeeAbstractMap* self);
 404         void (*reserved8) (GeeAbstractMap* self);
 405         void (*reserved9) (GeeAbstractMap* self);
 406         gint (*get_size) (GeeAbstractMap* self);
 407         gboolean (*get_read_only) (GeeAbstractMap* self);
 408         GeeSet* (*get_keys) (GeeAbstractMap* self);
 409         GeeCollection* (*get_values) (GeeAbstractMap* self);
 410         GeeSet* (*get_entries) (GeeAbstractMap* self);
 411         GeeMap* (*get_read_only_view) (GeeAbstractMap* self);
 412 };
 413
 414 struct _GeeHashMap {
 415         GeeAbstractMap parent_instance;
 416         GeeHashMapPrivate * priv;
 417 };
 418
 419 struct _GeeHashMapClass {
 420         GeeAbstractMapClass parent_class;
 421 };
 422
 423 typedef guint (*GeeHashDataFunc) (gconstpointer v, void* user_data);
 424 typedef gboolean (*GeeEqualDataFunc) (gconstpointer a, gconstpointer b, void* user_data);
 425 struct _GeeHashMapPrivate {
 426         GType k_type;
 427         GBoxedCopyFunc k_dup_func;
 428         GDestroyNotify k_destroy_func;
 429         GType v_type;
 430         GBoxedCopyFunc v_dup_func;
 431         GDestroyNotify v_destroy_func;
 432         GeeHashDataFunc _key_hash_func;
 433         gpointer _key_hash_func_target;
 434         GDestroyNotify _key_hash_func_target_destroy_notify;
 435         GeeEqualDataFunc _key_equal_func;
 436         gpointer _key_equal_func_target;
 437         GDestroyNotify _key_equal_func_target_destroy_notify;
 438         GeeEqualDataFunc _value_equal_func;
 439         gpointer _value_equal_func_target;
 440         GDestroyNotify _value_equal_func_target_destroy_notify;
 441         gint _array_size;
 442         gint _nnodes;
 443         GeeHashMapNode** _nodes;
 444         gint _nodes_length1;
 445         gint __nodes_size_;
 446         GeeSet* _keys;
 447         GeeCollection* _values;
 448         GeeSet* _entries;
 449         gint _stamp;
 450 };
 451
 452 struct _GeeHashMapNode {
 453         gpointer key;
 454         gpointer value;
 455         GeeHashMapNode* next;
 456         guint key_hash;
 457         GeeMapEntry* entry;
 458 };
 459
 460 struct _GeeMapEntry {
 461         GObject parent_instance;
 462         GeeMapEntryPrivate * priv;
 463 };
 464
 465 struct _GeeMapEntryClass {
 466         GObjectClass parent_class;
 467         gconstpointer (*get_key) (GeeMapEntry* self);
 468         gconstpointer (*get_value) (GeeMapEntry* self);
 469         void (*set_value) (GeeMapEntry* self, gconstpointer value);
 470         gboolean (*get_read_only) (GeeMapEntry* self);
 471 };
 472
 473 struct _GeeHashMapEntry {
 474         GeeMapEntry parent_instance;
 475         GeeHashMapEntryPrivate * priv;
 476 };
 477
 478 struct _GeeHashMapEntryClass {
 479         GeeMapEntryClass parent_class;
 480 };
 481
 482 struct _GeeHashMapEntryPrivate {
 483         GType k_type;
 484         GBoxedCopyFunc k_dup_func;
 485         GDestroyNotify k_destroy_func;
 486         GType v_type;
 487         GBoxedCopyFunc v_dup_func;
 488         GDestroyNotify v_destroy_func;
 489         GeeHashMapNode* _node;
 490 };
 491
 492 struct _GeeAbstractCollection {
 493         GObject parent_instance;
 494         GeeAbstractCollectionPrivate * priv;
 495 };
 496
 497 struct _GeeAbstractCollectionClass {
 498         GObjectClass parent_class;
 499         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 500         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 501         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 502         void (*clear) (GeeAbstractCollection* self);
 503         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 504         gboolean (*foreach) (GeeAbstractCollection* self, GeeForallFunc f, void* f_target);
 505         void (*reserved0) (GeeAbstractCollection* self);
 506         void (*reserved1) (GeeAbstractCollection* self);
 507         void (*reserved2) (GeeAbstractCollection* self);
 508         void (*reserved3) (GeeAbstractCollection* self);
 509         void (*reserved4) (GeeAbstractCollection* self);
 510         void (*reserved5) (GeeAbstractCollection* self);
 511         void (*reserved6) (GeeAbstractCollection* self);
 512         void (*reserved7) (GeeAbstractCollection* self);
 513         void (*reserved8) (GeeAbstractCollection* self);
 514         void (*reserved9) (GeeAbstractCollection* self);
 515         gint (*get_size) (GeeAbstractCollection* self);
 516         gboolean (*get_read_only) (GeeAbstractCollection* self);
 517         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 518 };
 519
 520 struct _GeeAbstractSet {
 521         GeeAbstractCollection parent_instance;
 522         GeeAbstractSetPrivate * priv;
 523 };
 524
 525 struct _GeeAbstractSetClass {
 526         GeeAbstractCollectionClass parent_class;
 527         void (*reserved0) (GeeAbstractSet* self);
 528         void (*reserved1) (GeeAbstractSet* self);
 529         void (*reserved2) (GeeAbstractSet* self);
 530         void (*reserved3) (GeeAbstractSet* self);
 531         void (*reserved4) (GeeAbstractSet* self);
 532         void (*reserved5) (GeeAbstractSet* self);
 533         void (*reserved6) (GeeAbstractSet* self);
 534         void (*reserved7) (GeeAbstractSet* self);
 535         void (*reserved8) (GeeAbstractSet* self);
 536         void (*reserved9) (GeeAbstractSet* self);
 537         GeeSet* (*get_read_only_view) (GeeAbstractSet* self);
 538 };
 539
 540 struct _GeeHashMapKeySet {
 541         GeeAbstractSet parent_instance;
 542         GeeHashMapKeySetPrivate * priv;
 543 };
 544
 545 struct _GeeHashMapKeySetClass {
 546         GeeAbstractSetClass parent_class;
 547 };
 548
 549 struct _GeeHashMapKeySetPrivate {
 550         GType k_type;
 551         GBoxedCopyFunc k_dup_func;
 552         GDestroyNotify k_destroy_func;
 553         GType v_type;
 554         GBoxedCopyFunc v_dup_func;
 555         GDestroyNotify v_destroy_func;
 556         GeeHashMap* _map;
 557 };
 558
 559 struct _GeeHashMapValueCollection {
 560         GeeAbstractCollection parent_instance;
 561         GeeHashMapValueCollectionPrivate * priv;
 562 };
 563
 564 struct _GeeHashMapValueCollectionClass {
 565         GeeAbstractCollectionClass parent_class;
 566 };
 567
 568 struct _GeeHashMapValueCollectionPrivate {
 569         GType k_type;
 570         GBoxedCopyFunc k_dup_func;
 571         GDestroyNotify k_destroy_func;
 572         GType v_type;
 573         GBoxedCopyFunc v_dup_func;
 574         GDestroyNotify v_destroy_func;
 575         GeeHashMap* _map;
 576 };
 577
 578 struct _GeeHashMapEntrySet {
 579         GeeAbstractSet parent_instance;
 580         GeeHashMapEntrySetPrivate * priv;
 581 };
 582
 583 struct _GeeHashMapEntrySetClass {
 584         GeeAbstractSetClass parent_class;
 585 };
 586
 587 struct _GeeHashMapEntrySetPrivate {
 588         GType k_type;
 589         GBoxedCopyFunc k_dup_func;
 590         GDestroyNotify k_destroy_func;
 591         GType v_type;
 592         GBoxedCopyFunc v_dup_func;
 593         GDestroyNotify v_destroy_func;
 594         GeeHashMap* _map;
 595 };
 596
 597 struct _GeeHashMapNodeIterator {
 598         GObject parent_instance;
 599         GeeHashMapNodeIteratorPrivate * priv;
 600         GeeHashMap* _map;
 601         gint _index;
 602         GeeHashMapNode* _node;
 603         GeeHashMapNode* _next;
 604         gint _stamp;
 605 };
 606
 607 struct _GeeHashMapNodeIteratorClass {
 608         GObjectClass parent_class;
 609         gboolean (*get_read_only) (GeeHashMapNodeIterator* self);
 610 };
 611
 612 struct _GeeHashMapNodeIteratorPrivate {
 613         GType k_type;
 614         GBoxedCopyFunc k_dup_func;
 615         GDestroyNotify k_destroy_func;
 616         GType v_type;
 617         GBoxedCopyFunc v_dup_func;
 618         GDestroyNotify v_destroy_func;
 619 };
 620
 621 struct _GeeHashMapKeyIterator {
 622         GeeHashMapNodeIterator parent_instance;
 623         GeeHashMapKeyIteratorPrivate * priv;
 624 };
 625
 626 struct _GeeHashMapKeyIteratorClass {
 627         GeeHashMapNodeIteratorClass parent_class;
 628 };
 629
 630 struct _GeeHashMapKeyIteratorPrivate {
 631         GType k_type;
 632         GBoxedCopyFunc k_dup_func;
 633         GDestroyNotify k_destroy_func;
 634         GType v_type;
 635         GBoxedCopyFunc v_dup_func;
 636         GDestroyNotify v_destroy_func;
 637 };
 638
 639 struct _GeeHashMapMapIterator {
 640         GeeHashMapNodeIterator parent_instance;
 641         GeeHashMapMapIteratorPrivate * priv;
 642 };
 643
 644 struct _GeeHashMapMapIteratorClass {
 645         GeeHashMapNodeIteratorClass parent_class;
 646 };
 647
 648 struct _GeeHashMapMapIteratorPrivate {
 649         GType k_type;
 650         GBoxedCopyFunc k_dup_func;
 651         GDestroyNotify k_destroy_func;
 652         GType v_type;
 653         GBoxedCopyFunc v_dup_func;
 654         GDestroyNotify v_destroy_func;
 655 };
 656
 657 struct _GeeHashMapValueIterator {
 658         GeeHashMapNodeIterator parent_instance;
 659         GeeHashMapValueIteratorPrivate * priv;
 660 };
 661
 662 struct _GeeHashMapValueIteratorClass {
 663         GeeHashMapNodeIteratorClass parent_class;
 664 };
 665
 666 struct _GeeHashMapValueIteratorPrivate {
 667         GType k_type;
 668         GBoxedCopyFunc k_dup_func;
 669         GDestroyNotify k_destroy_func;
 670         GType v_type;
 671         GBoxedCopyFunc v_dup_func;
 672         GDestroyNotify v_destroy_func;
 673 };
 674
 675 struct _GeeHashMapEntryIterator {
 676         GeeHashMapNodeIterator parent_instance;
 677         GeeHashMapEntryIteratorPrivate * priv;
 678 };
 679
 680 struct _GeeHashMapEntryIteratorClass {
 681         GeeHashMapNodeIteratorClass parent_class;
 682 };
 683
 684 struct _GeeHashMapEntryIteratorPrivate {
 685         GType k_type;
 686         GBoxedCopyFunc k_dup_func;
 687         GDestroyNotify k_destroy_func;
 688         GType v_type;
 689         GBoxedCopyFunc v_dup_func;
 690         GDestroyNotify v_destroy_func;
 691 };
 692
 693
 694 static gpointer gee_hash_map_parent_class = NULL;
 695 static gpointer gee_hash_map_entry_parent_class = NULL;
 696 static gpointer gee_hash_map_key_set_parent_class = NULL;
 697 static gpointer gee_hash_map_value_collection_parent_class = NULL;
 698 static gpointer gee_hash_map_entry_set_parent_class = NULL;
 699 static gpointer gee_hash_map_node_iterator_parent_class = NULL;
 700 static gpointer gee_hash_map_key_iterator_parent_class = NULL;
 701 static GeeTraversableIface* gee_hash_map_key_iterator_gee_traversable_parent_iface = NULL;
 702 static GeeIteratorIface* gee_hash_map_key_iterator_gee_iterator_parent_iface = NULL;
 703 static gpointer gee_hash_map_map_iterator_parent_class = NULL;
 704 static GeeMapIteratorIface* gee_hash_map_map_iterator_gee_map_iterator_parent_iface = NULL;
 705 static gpointer gee_hash_map_value_iterator_parent_class = NULL;
 706 static GeeTraversableIface* gee_hash_map_value_iterator_gee_traversable_parent_iface = NULL;
 707 static GeeIteratorIface* gee_hash_map_value_iterator_gee_iterator_parent_iface = NULL;
 708 static gpointer gee_hash_map_entry_iterator_parent_class = NULL;
 709 static GeeTraversableIface* gee_hash_map_entry_iterator_gee_traversable_parent_iface = NULL;
 710 static GeeIteratorIface* gee_hash_map_entry_iterator_gee_iterator_parent_iface = NULL;
 711
 712 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 713 gpointer gee_lazy_ref (gpointer instance);
 714 void gee_lazy_unref (gpointer instance);
 715 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 716 void gee_value_set_lazy (GValue* value, gpointer v_object);
 717 void gee_value_take_lazy (GValue* value, gpointer v_object);
 718 gpointer gee_value_get_lazy (const GValue* value);
 719 GType gee_lazy_get_type (void) G_GNUC_CONST;
 720 GType gee_iterator_get_type (void) G_GNUC_CONST;
 721 GType gee_traversable_get_type (void) G_GNUC_CONST;
 722 GType gee_iterable_get_type (void) G_GNUC_CONST;
 723 GType gee_map_iterator_get_type (void) G_GNUC_CONST;
 724 GType gee_collection_get_type (void) G_GNUC_CONST;
 725 GType gee_set_get_type (void) G_GNUC_CONST;
 726 GType gee_map_entry_get_type (void) G_GNUC_CONST;
 727 GType gee_map_get_type (void) G_GNUC_CONST;
 728 GType gee_abstract_map_get_type (void) G_GNUC_CONST;
 729 GType gee_hash_map_get_type (void) G_GNUC_CONST;
 730 static void gee_hash_map_node_free (GeeHashMapNode* self);
 731 #define GEE_HASH_MAP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_HASH_MAP, GeeHashMapPrivate))
 732 enum  {
 733         GEE_HASH_MAP_DUMMY_PROPERTY,
 734         GEE_HASH_MAP_K_TYPE,
 735         GEE_HASH_MAP_K_DUP_FUNC,
 736         GEE_HASH_MAP_K_DESTROY_FUNC,
 737         GEE_HASH_MAP_V_TYPE,
 738         GEE_HASH_MAP_V_DUP_FUNC,
 739         GEE_HASH_MAP_V_DESTROY_FUNC,
 740         GEE_HASH_MAP_SIZE,
 741         GEE_HASH_MAP_READ_ONLY,
 742         GEE_HASH_MAP_KEYS,
 743         GEE_HASH_MAP_VALUES,
 744         GEE_HASH_MAP_ENTRIES
 745 };
 746 void gee_abstract_map_clear (GeeAbstractMap* self);
 747 #define GEE_HASH_MAP_MIN_SIZE 11
 748 #define GEE_HASH_MAP_MAX_SIZE 13845163
 749 GeeHashMap* gee_hash_map_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashDataFunc key_hash_func, void* key_hash_func_target, GDestroyNotify key_hash_func_target_destroy_notify, GeeEqualDataFunc key_equal_func, void* key_equal_func_target, GDestroyNotify key_equal_func_target_destroy_notify, GeeEqualDataFunc value_equal_func, void* value_equal_func_target, GDestroyNotify value_equal_func_target_destroy_notify);
 750 GeeHashMap* gee_hash_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashDataFunc key_hash_func, void* key_hash_func_target, GDestroyNotify key_hash_func_target_destroy_notify, GeeEqualDataFunc key_equal_func, void* key_equal_func_target, GDestroyNotify key_equal_func_target_destroy_notify, GeeEqualDataFunc value_equal_func, void* value_equal_func_target, GDestroyNotify value_equal_func_target_destroy_notify);
 751 GeeAbstractMap* gee_abstract_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func);
 752 GeeHashDataFunc gee_functions_get_hash_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
 753 GeeEqualDataFunc gee_functions_get_equal_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
 754 static void gee_hash_map_set_key_hash_func (GeeHashMap* self, GeeHashDataFunc value, gpointer value_target);
 755 static void gee_hash_map_set_key_equal_func (GeeHashMap* self, GeeEqualDataFunc value, gpointer value_target);
 756 static void gee_hash_map_set_value_equal_func (GeeHashMap* self, GeeEqualDataFunc value, gpointer value_target);
 757 static GeeHashMapNode** gee_hash_map_lookup_node (GeeHashMap* self, gconstpointer key);
 758 GeeHashDataFunc gee_hash_map_get_key_hash_func (GeeHashMap* self, gpointer* result_target);
 759 GeeEqualDataFunc gee_hash_map_get_key_equal_func (GeeHashMap* self, gpointer* result_target);
 760 static gboolean gee_hash_map_real_has_key (GeeAbstractMap* base, gconstpointer key);
 761 static gboolean gee_hash_map_real_has (GeeAbstractMap* base, gconstpointer key, gconstpointer value);
 762 GeeEqualDataFunc gee_hash_map_get_value_equal_func (GeeHashMap* self, gpointer* result_target);
 763 static gpointer gee_hash_map_real_get (GeeAbstractMap* base, gconstpointer key);
 764 static void gee_hash_map_real_set (GeeAbstractMap* base, gconstpointer key, gconstpointer value);
 765 static GeeHashMapNode* gee_hash_map_node_new (gpointer k, gpointer v, guint hash);
 766 static GeeHashMapNode* gee_hash_map_node_new (gpointer k, gpointer v, guint hash);
 767 static inline void gee_hash_map_resize (GeeHashMap* self);
 768 static gboolean gee_hash_map_real_unset (GeeAbstractMap* base, gconstpointer key, gpointer* value);
 769 static inline gboolean gee_hash_map_unset_helper (GeeHashMap* self, gconstpointer key, gpointer* value);
 770 static void gee_hash_map_real_clear (GeeAbstractMap* base);
 771 static GeeMapIterator* gee_hash_map_real_map_iterator (GeeAbstractMap* base);
 772 static GeeHashMapMapIterator* gee_hash_map_map_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 773 static GeeHashMapMapIterator* gee_hash_map_map_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 774 static GType gee_hash_map_node_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 775 static GType gee_hash_map_map_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 776 static GeeHashMapKeySet* gee_hash_map_key_set_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 777 static GeeHashMapKeySet* gee_hash_map_key_set_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 778 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 779 GType gee_abstract_set_get_type (void) G_GNUC_CONST;
 780 static GType gee_hash_map_key_set_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 781 static GeeHashMapValueCollection* gee_hash_map_value_collection_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 782 static GeeHashMapValueCollection* gee_hash_map_value_collection_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 783 static GType gee_hash_map_value_collection_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 784 static GeeHashMapEntrySet* gee_hash_map_entry_set_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 785 static GeeHashMapEntrySet* gee_hash_map_entry_set_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 786 static GType gee_hash_map_entry_set_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 787 static void gee_hash_map_node_instance_init (GeeHashMapNode * self);
 788 static GType gee_hash_map_entry_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 789 #define GEE_HASH_MAP_ENTRY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_ENTRY, GeeHashMapEntryPrivate))
 790 enum  {
 791         GEE_HASH_MAP_ENTRY_DUMMY_PROPERTY,
 792         GEE_HASH_MAP_ENTRY_K_TYPE,
 793         GEE_HASH_MAP_ENTRY_K_DUP_FUNC,
 794         GEE_HASH_MAP_ENTRY_K_DESTROY_FUNC,
 795         GEE_HASH_MAP_ENTRY_V_TYPE,
 796         GEE_HASH_MAP_ENTRY_V_DUP_FUNC,
 797         GEE_HASH_MAP_ENTRY_V_DESTROY_FUNC,
 798         GEE_HASH_MAP_ENTRY_KEY,
 799         GEE_HASH_MAP_ENTRY_VALUE,
 800         GEE_HASH_MAP_ENTRY_READ_ONLY
 801 };
 802 static GeeMapEntry* gee_hash_map_entry_entry_for (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMapNode* node);
 803 static GeeHashMapEntry* gee_hash_map_entry_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMapNode* node);
 804 static GeeHashMapEntry* gee_hash_map_entry_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMapNode* node);
 805 GeeMapEntry* gee_map_entry_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func);
 806 static void gee_hash_map_entry_finalize (GObject* obj);
 807 gconstpointer gee_map_entry_get_key (GeeMapEntry* self);
 808 gconstpointer gee_map_entry_get_value (GeeMapEntry* self);
 809 gboolean gee_map_entry_get_read_only (GeeMapEntry* self);
 810 static void _vala_gee_hash_map_entry_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 811 void gee_map_entry_set_value (GeeMapEntry* self, gconstpointer value);
 812 static void _vala_gee_hash_map_entry_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 813 #define GEE_HASH_MAP_KEY_SET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_KEY_SET, GeeHashMapKeySetPrivate))
 814 enum  {
 815         GEE_HASH_MAP_KEY_SET_DUMMY_PROPERTY,
 816         GEE_HASH_MAP_KEY_SET_K_TYPE,
 817         GEE_HASH_MAP_KEY_SET_K_DUP_FUNC,
 818         GEE_HASH_MAP_KEY_SET_K_DESTROY_FUNC,
 819         GEE_HASH_MAP_KEY_SET_V_TYPE,
 820         GEE_HASH_MAP_KEY_SET_V_DUP_FUNC,
 821         GEE_HASH_MAP_KEY_SET_V_DESTROY_FUNC,
 822         GEE_HASH_MAP_KEY_SET_SIZE,
 823         GEE_HASH_MAP_KEY_SET_READ_ONLY
 824 };
 825 GeeAbstractSet* gee_abstract_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 826 static GeeIterator* gee_hash_map_key_set_real_iterator (GeeAbstractCollection* base);
 827 static GeeHashMapKeyIterator* gee_hash_map_key_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 828 static GeeHashMapKeyIterator* gee_hash_map_key_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 829 static GType gee_hash_map_key_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 830 static gboolean gee_hash_map_key_set_real_add (GeeAbstractCollection* base, gconstpointer key);
 831 static void gee_hash_map_key_set_real_clear (GeeAbstractCollection* base);
 832 static gboolean gee_hash_map_key_set_real_remove (GeeAbstractCollection* base, gconstpointer key);
 833 static gboolean gee_hash_map_key_set_real_contains (GeeAbstractCollection* base, gconstpointer key);
 834 gboolean gee_abstract_map_has_key (GeeAbstractMap* self, gconstpointer key);
 835 static gboolean gee_hash_map_key_set_add_all (GeeHashMapKeySet* self, GeeCollection* collection);
 836 static gboolean gee_hash_map_key_set_remove_all (GeeHashMapKeySet* self, GeeCollection* collection);
 837 static gboolean gee_hash_map_key_set_retain_all (GeeHashMapKeySet* self, GeeCollection* collection);
 838 gint gee_abstract_map_get_size (GeeAbstractMap* self);
 839 static void gee_hash_map_key_set_finalize (GObject* obj);
 840 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 841 gboolean gee_abstract_collection_get_read_only (GeeAbstractCollection* self);
 842 static void _vala_gee_hash_map_key_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 843 static void _vala_gee_hash_map_key_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 844 #define GEE_HASH_MAP_VALUE_COLLECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_VALUE_COLLECTION, GeeHashMapValueCollectionPrivate))
 845 enum  {
 846         GEE_HASH_MAP_VALUE_COLLECTION_DUMMY_PROPERTY,
 847         GEE_HASH_MAP_VALUE_COLLECTION_K_TYPE,
 848         GEE_HASH_MAP_VALUE_COLLECTION_K_DUP_FUNC,
 849         GEE_HASH_MAP_VALUE_COLLECTION_K_DESTROY_FUNC,
 850         GEE_HASH_MAP_VALUE_COLLECTION_V_TYPE,
 851         GEE_HASH_MAP_VALUE_COLLECTION_V_DUP_FUNC,
 852         GEE_HASH_MAP_VALUE_COLLECTION_V_DESTROY_FUNC,
 853         GEE_HASH_MAP_VALUE_COLLECTION_SIZE,
 854         GEE_HASH_MAP_VALUE_COLLECTION_READ_ONLY
 855 };
 856 GeeAbstractCollection* gee_abstract_collection_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 857 static GeeIterator* gee_hash_map_value_collection_real_iterator (GeeAbstractCollection* base);
 858 static GeeHashMapValueIterator* gee_hash_map_value_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 859 static GeeHashMapValueIterator* gee_hash_map_value_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 860 static GType gee_hash_map_value_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 861 static gboolean gee_hash_map_value_collection_real_add (GeeAbstractCollection* base, gconstpointer value);
 862 static void gee_hash_map_value_collection_real_clear (GeeAbstractCollection* base);
 863 static gboolean gee_hash_map_value_collection_real_remove (GeeAbstractCollection* base, gconstpointer value);
 864 static gboolean gee_hash_map_value_collection_real_contains (GeeAbstractCollection* base, gconstpointer value);
 865 GeeIterator* gee_abstract_collection_iterator (GeeAbstractCollection* self);
 866 gboolean gee_iterator_next (GeeIterator* self);
 867 gpointer gee_iterator_get (GeeIterator* self);
 868 static gboolean gee_hash_map_value_collection_add_all (GeeHashMapValueCollection* self, GeeCollection* collection);
 869 static gboolean gee_hash_map_value_collection_remove_all (GeeHashMapValueCollection* self, GeeCollection* collection);
 870 static gboolean gee_hash_map_value_collection_retain_all (GeeHashMapValueCollection* self, GeeCollection* collection);
 871 static void gee_hash_map_value_collection_finalize (GObject* obj);
 872 static void _vala_gee_hash_map_value_collection_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 873 static void _vala_gee_hash_map_value_collection_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 874 #define GEE_HASH_MAP_ENTRY_SET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_ENTRY_SET, GeeHashMapEntrySetPrivate))
 875 enum  {
 876         GEE_HASH_MAP_ENTRY_SET_DUMMY_PROPERTY,
 877         GEE_HASH_MAP_ENTRY_SET_K_TYPE,
 878         GEE_HASH_MAP_ENTRY_SET_K_DUP_FUNC,
 879         GEE_HASH_MAP_ENTRY_SET_K_DESTROY_FUNC,
 880         GEE_HASH_MAP_ENTRY_SET_V_TYPE,
 881         GEE_HASH_MAP_ENTRY_SET_V_DUP_FUNC,
 882         GEE_HASH_MAP_ENTRY_SET_V_DESTROY_FUNC,
 883         GEE_HASH_MAP_ENTRY_SET_SIZE,
 884         GEE_HASH_MAP_ENTRY_SET_READ_ONLY
 885 };
 886 static GeeIterator* gee_hash_map_entry_set_real_iterator (GeeAbstractCollection* base);
 887 static GeeHashMapEntryIterator* gee_hash_map_entry_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 888 static GeeHashMapEntryIterator* gee_hash_map_entry_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 889 static GType gee_hash_map_entry_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 890 static gboolean gee_hash_map_entry_set_real_add (GeeAbstractCollection* base, GeeMapEntry* entry);
 891 static void gee_hash_map_entry_set_real_clear (GeeAbstractCollection* base);
 892 static gboolean gee_hash_map_entry_set_real_remove (GeeAbstractCollection* base, GeeMapEntry* entry);
 893 static gboolean gee_hash_map_entry_set_real_contains (GeeAbstractCollection* base, GeeMapEntry* entry);
 894 gboolean gee_abstract_map_has (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 895 static gboolean gee_hash_map_entry_set_add_all (GeeHashMapEntrySet* self, GeeCollection* entries);
 896 static gboolean gee_hash_map_entry_set_remove_all (GeeHashMapEntrySet* self, GeeCollection* entries);
 897 static gboolean gee_hash_map_entry_set_retain_all (GeeHashMapEntrySet* self, GeeCollection* entries);
 898 static void gee_hash_map_entry_set_finalize (GObject* obj);
 899 static void _vala_gee_hash_map_entry_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 900 static void _vala_gee_hash_map_entry_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 901 #define GEE_HASH_MAP_NODE_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_NODE_ITERATOR, GeeHashMapNodeIteratorPrivate))
 902 enum  {
 903         GEE_HASH_MAP_NODE_ITERATOR_DUMMY_PROPERTY,
 904         GEE_HASH_MAP_NODE_ITERATOR_K_TYPE,
 905         GEE_HASH_MAP_NODE_ITERATOR_K_DUP_FUNC,
 906         GEE_HASH_MAP_NODE_ITERATOR_K_DESTROY_FUNC,
 907         GEE_HASH_MAP_NODE_ITERATOR_V_TYPE,
 908         GEE_HASH_MAP_NODE_ITERATOR_V_DUP_FUNC,
 909         GEE_HASH_MAP_NODE_ITERATOR_V_DESTROY_FUNC,
 910         GEE_HASH_MAP_NODE_ITERATOR_READ_ONLY,
 911         GEE_HASH_MAP_NODE_ITERATOR_VALID
 912 };
 913 static GeeHashMapNodeIterator* gee_hash_map_node_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map);
 914 static gboolean gee_hash_map_node_iterator_next (GeeHashMapNodeIterator* self);
 915 static gboolean gee_hash_map_node_iterator_has_next (GeeHashMapNodeIterator* self);
 916 static gboolean gee_hash_map_node_iterator_get_read_only (GeeHashMapNodeIterator* self);
 917 static gboolean gee_hash_map_node_iterator_get_valid (GeeHashMapNodeIterator* self);
 918 static void gee_hash_map_node_iterator_finalize (GObject* obj);
 919 static void _vala_gee_hash_map_node_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 920 static void _vala_gee_hash_map_node_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 921 #define GEE_HASH_MAP_KEY_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_KEY_ITERATOR, GeeHashMapKeyIteratorPrivate))
 922 enum  {
 923         GEE_HASH_MAP_KEY_ITERATOR_DUMMY_PROPERTY,
 924         GEE_HASH_MAP_KEY_ITERATOR_K_TYPE,
 925         GEE_HASH_MAP_KEY_ITERATOR_K_DUP_FUNC,
 926         GEE_HASH_MAP_KEY_ITERATOR_K_DESTROY_FUNC,
 927         GEE_HASH_MAP_KEY_ITERATOR_V_TYPE,
 928         GEE_HASH_MAP_KEY_ITERATOR_V_DUP_FUNC,
 929         GEE_HASH_MAP_KEY_ITERATOR_V_DESTROY_FUNC
 930 };
 931 static gpointer gee_hash_map_key_iterator_real_get (GeeIterator* base);
 932 static void gee_hash_map_key_iterator_real_remove (GeeIterator* base);
 933 static gboolean gee_hash_map_key_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 934 static void _vala_gee_hash_map_key_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 935 static void _vala_gee_hash_map_key_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 936 #define GEE_HASH_MAP_MAP_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_MAP_ITERATOR, GeeHashMapMapIteratorPrivate))
 937 enum  {
 938         GEE_HASH_MAP_MAP_ITERATOR_DUMMY_PROPERTY,
 939         GEE_HASH_MAP_MAP_ITERATOR_K_TYPE,
 940         GEE_HASH_MAP_MAP_ITERATOR_K_DUP_FUNC,
 941         GEE_HASH_MAP_MAP_ITERATOR_K_DESTROY_FUNC,
 942         GEE_HASH_MAP_MAP_ITERATOR_V_TYPE,
 943         GEE_HASH_MAP_MAP_ITERATOR_V_DUP_FUNC,
 944         GEE_HASH_MAP_MAP_ITERATOR_V_DESTROY_FUNC,
 945         GEE_HASH_MAP_MAP_ITERATOR_MUTABLE,
 946         GEE_HASH_MAP_MAP_ITERATOR_READ_ONLY
 947 };
 948 static gpointer gee_hash_map_map_iterator_real_get_key (GeeMapIterator* base);
 949 static void gee_hash_map_map_iterator_real_unset (GeeMapIterator* base);
 950 gboolean gee_map_iterator_has_next (GeeMapIterator* self);
 951 static gpointer gee_hash_map_map_iterator_real_get_value (GeeMapIterator* base);
 952 static void gee_hash_map_map_iterator_real_set_value (GeeMapIterator* base, gconstpointer value);
 953 void gee_abstract_map_set (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 954 gboolean gee_map_iterator_get_mutable (GeeMapIterator* self);
 955 static void _vala_gee_hash_map_map_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 956 static void _vala_gee_hash_map_map_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 957 #define GEE_HASH_MAP_VALUE_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_VALUE_ITERATOR, GeeHashMapValueIteratorPrivate))
 958 enum  {
 959         GEE_HASH_MAP_VALUE_ITERATOR_DUMMY_PROPERTY,
 960         GEE_HASH_MAP_VALUE_ITERATOR_K_TYPE,
 961         GEE_HASH_MAP_VALUE_ITERATOR_K_DUP_FUNC,
 962         GEE_HASH_MAP_VALUE_ITERATOR_K_DESTROY_FUNC,
 963         GEE_HASH_MAP_VALUE_ITERATOR_V_TYPE,
 964         GEE_HASH_MAP_VALUE_ITERATOR_V_DUP_FUNC,
 965         GEE_HASH_MAP_VALUE_ITERATOR_V_DESTROY_FUNC
 966 };
 967 static gpointer gee_hash_map_value_iterator_real_get (GeeIterator* base);
 968 static void gee_hash_map_value_iterator_real_remove (GeeIterator* base);
 969 static gboolean gee_hash_map_value_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 970 static void _vala_gee_hash_map_value_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 971 static void _vala_gee_hash_map_value_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 972 #define GEE_HASH_MAP_ENTRY_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_HASH_MAP_TYPE_ENTRY_ITERATOR, GeeHashMapEntryIteratorPrivate))
 973 enum  {
 974         GEE_HASH_MAP_ENTRY_ITERATOR_DUMMY_PROPERTY,
 975         GEE_HASH_MAP_ENTRY_ITERATOR_K_TYPE,
 976         GEE_HASH_MAP_ENTRY_ITERATOR_K_DUP_FUNC,
 977         GEE_HASH_MAP_ENTRY_ITERATOR_K_DESTROY_FUNC,
 978         GEE_HASH_MAP_ENTRY_ITERATOR_V_TYPE,
 979         GEE_HASH_MAP_ENTRY_ITERATOR_V_DUP_FUNC,
 980         GEE_HASH_MAP_ENTRY_ITERATOR_V_DESTROY_FUNC
 981 };
 982 static GeeMapEntry* gee_hash_map_entry_iterator_real_get (GeeIterator* base);
 983 static void gee_hash_map_entry_iterator_real_remove (GeeIterator* base);
 984 static gboolean gee_hash_map_entry_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 985 static void _vala_gee_hash_map_entry_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 986 static void _vala_gee_hash_map_entry_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 987 static void gee_hash_map_finalize (GObject* obj);
 988 gboolean gee_abstract_map_get_read_only (GeeAbstractMap* self);
 989 GeeSet* gee_abstract_map_get_keys (GeeAbstractMap* self);
 990 GeeCollection* gee_abstract_map_get_values (GeeAbstractMap* self);
 991 GeeSet* gee_abstract_map_get_entries (GeeAbstractMap* self);
 992 static void _vala_gee_hash_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 993 static void _vala_gee_hash_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 994 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 995 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 996
 997
 998 /**
 999  * Constructs a new, empty hash map.
1000  *
1001  * If not provided, the functions parameters are requested to the
1002  * {@link Functions} function factory methods.
1003  *
1004  * @param key_hash_func an optional key hash function
1005  * @param key_equal_func an optional key equality testing function
1006  * @param value_equal_func an optional value equality testing function
1007  */
1008 GeeHashMap* gee_hash_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashDataFunc key_hash_func, void* key_hash_func_target, GDestroyNotify key_hash_func_target_destroy_notify, GeeEqualDataFunc key_equal_func, void* key_equal_func_target, GDestroyNotify key_equal_func_target_destroy_notify, GeeEqualDataFunc value_equal_func, void* value_equal_func_target, GDestroyNotify value_equal_func_target_destroy_notify) {
1009         GeeHashMap * self = NULL;
1010         GeeHashDataFunc _tmp0_;
1011         void* _tmp0__target;
1012         GeeEqualDataFunc _tmp4_;
1013         void* _tmp4__target;
1014         GeeEqualDataFunc _tmp8_;
1015         void* _tmp8__target;
1016         GeeHashDataFunc _tmp12_;
1017         void* _tmp12__target;
1018         GeeEqualDataFunc _tmp13_;
1019         void* _tmp13__target;
1020         GeeEqualDataFunc _tmp14_;
1021         void* _tmp14__target;
1022         gint _tmp15_;
1023         GeeHashMapNode** _tmp16_ = NULL;
1024         self = (GeeHashMap*) gee_abstract_map_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func);
1025         self->priv->k_type = k_type;
1026         self->priv->k_dup_func = k_dup_func;
1027         self->priv->k_destroy_func = k_destroy_func;
1028         self->priv->v_type = v_type;
1029         self->priv->v_dup_func = v_dup_func;
1030         self->priv->v_destroy_func = v_destroy_func;
1031         _tmp0_ = key_hash_func;
1032         _tmp0__target = key_hash_func_target;
1033         if (_tmp0_ == NULL) {
1034                 void* _tmp1_ = NULL;
1035                 GDestroyNotify _tmp2_ = NULL;
1036                 GeeHashDataFunc _tmp3_ = NULL;
1037                 _tmp3_ = gee_functions_get_hash_func_for (k_type, &_tmp1_, &_tmp2_);
1038                 (key_hash_func_target_destroy_notify == NULL) ? NULL : (key_hash_func_target_destroy_notify (key_hash_func_target), NULL);
1039                 key_hash_func = NULL;
1040                 key_hash_func_target = NULL;
1041                 key_hash_func_target_destroy_notify = NULL;
1042                 key_hash_func = _tmp3_;
1043                 key_hash_func_target = _tmp1_;
1044                 key_hash_func_target_destroy_notify = _tmp2_;
1045         }
1046         _tmp4_ = key_equal_func;
1047         _tmp4__target = key_equal_func_target;
1048         if (_tmp4_ == NULL) {
1049                 void* _tmp5_ = NULL;
1050                 GDestroyNotify _tmp6_ = NULL;
1051                 GeeEqualDataFunc _tmp7_ = NULL;
1052                 _tmp7_ = gee_functions_get_equal_func_for (k_type, &_tmp5_, &_tmp6_);
1053                 (key_equal_func_target_destroy_notify == NULL) ? NULL : (key_equal_func_target_destroy_notify (key_equal_func_target), NULL);
1054                 key_equal_func = NULL;
1055                 key_equal_func_target = NULL;
1056                 key_equal_func_target_destroy_notify = NULL;
1057                 key_equal_func = _tmp7_;
1058                 key_equal_func_target = _tmp5_;
1059                 key_equal_func_target_destroy_notify = _tmp6_;
1060         }
1061         _tmp8_ = value_equal_func;
1062         _tmp8__target = value_equal_func_target;
1063         if (_tmp8_ == NULL) {
1064                 void* _tmp9_ = NULL;
1065                 GDestroyNotify _tmp10_ = NULL;
1066                 GeeEqualDataFunc _tmp11_ = NULL;
1067                 _tmp11_ = gee_functions_get_equal_func_for (v_type, &_tmp9_, &_tmp10_);
1068                 (value_equal_func_target_destroy_notify == NULL) ? NULL : (value_equal_func_target_destroy_notify (value_equal_func_target), NULL);
1069                 value_equal_func = NULL;
1070                 value_equal_func_target = NULL;
1071                 value_equal_func_target_destroy_notify = NULL;
1072                 value_equal_func = _tmp11_;
1073                 value_equal_func_target = _tmp9_;
1074                 value_equal_func_target_destroy_notify = _tmp10_;
1075         }
1076         _tmp12_ = key_hash_func;
1077         _tmp12__target = key_hash_func_target;
1078         gee_hash_map_set_key_hash_func (self, _tmp12_, _tmp12__target);
1079         _tmp13_ = key_equal_func;
1080         _tmp13__target = key_equal_func_target;
1081         gee_hash_map_set_key_equal_func (self, _tmp13_, _tmp13__target);
1082         _tmp14_ = value_equal_func;
1083         _tmp14__target = value_equal_func_target;
1084         gee_hash_map_set_value_equal_func (self, _tmp14_, _tmp14__target);
1085         self->priv->_array_size = GEE_HASH_MAP_MIN_SIZE;
1086         _tmp15_ = self->priv->_array_size;
1087         _tmp16_ = g_new0 (GeeHashMapNode*, _tmp15_ + 1);
1088         self->priv->_nodes = (_vala_array_free (self->priv->_nodes, self->priv->_nodes_length1, (GDestroyNotify) gee_hash_map_node_free), NULL);
1089         self->priv->_nodes = _tmp16_;
1090         self->priv->_nodes_length1 = _tmp15_;
1091         self->priv->__nodes_size_ = self->priv->_nodes_length1;
1092         (key_hash_func_target_destroy_notify == NULL) ? NULL : (key_hash_func_target_destroy_notify (key_hash_func_target), NULL);
1093         key_hash_func = NULL;
1094         key_hash_func_target = NULL;
1095         key_hash_func_target_destroy_notify = NULL;
1096         (key_equal_func_target_destroy_notify == NULL) ? NULL : (key_equal_func_target_destroy_notify (key_equal_func_target), NULL);
1097         key_equal_func = NULL;
1098         key_equal_func_target = NULL;
1099         key_equal_func_target_destroy_notify = NULL;
1100         (value_equal_func_target_destroy_notify == NULL) ? NULL : (value_equal_func_target_destroy_notify (value_equal_func_target), NULL);
1101         value_equal_func = NULL;
1102         value_equal_func_target = NULL;
1103         value_equal_func_target_destroy_notify = NULL;
1104         return self;
1105 }
1106
1107
1108 GeeHashMap* gee_hash_map_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashDataFunc key_hash_func, void* key_hash_func_target, GDestroyNotify key_hash_func_target_destroy_notify, GeeEqualDataFunc key_equal_func, void* key_equal_func_target, GDestroyNotify key_equal_func_target_destroy_notify, GeeEqualDataFunc value_equal_func, void* value_equal_func_target, GDestroyNotify value_equal_func_target_destroy_notify) {
1109         return gee_hash_map_construct (GEE_TYPE_HASH_MAP, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, key_hash_func, key_hash_func_target, key_hash_func_target_destroy_notify, key_equal_func, key_equal_func_target, key_equal_func_target_destroy_notify, value_equal_func, value_equal_func_target, value_equal_func_target_destroy_notify);
1110 }
1111
1112
1113 static GeeHashMapNode** gee_hash_map_lookup_node (GeeHashMap* self, gconstpointer key) {
1114         GeeHashMapNode** result = NULL;
1115         GeeHashDataFunc _tmp0_;
1116         void* _tmp0__target;
1117         GeeHashDataFunc _tmp1_;
1118         void* _tmp1__target;
1119         gconstpointer _tmp2_;
1120         guint _tmp3_ = 0U;
1121         guint hash_value;
1122         GeeHashMapNode** _tmp4_;
1123         gint _tmp4__length1;
1124         guint _tmp5_;
1125         gint _tmp6_;
1126         GeeHashMapNode** node;
1127         GeeHashMapNode** _tmp22_;
1128         g_return_val_if_fail (self != NULL, NULL);
1129         _tmp0_ = gee_hash_map_get_key_hash_func (self, &_tmp0__target);
1130         _tmp1_ = _tmp0_;
1131         _tmp1__target = _tmp0__target;
1132         _tmp2_ = key;
1133         _tmp3_ = _tmp1_ (_tmp2_, _tmp1__target);
1134         hash_value = _tmp3_;
1135         _tmp4_ = self->priv->_nodes;
1136         _tmp4__length1 = self->priv->_nodes_length1;
1137         _tmp5_ = hash_value;
1138         _tmp6_ = self->priv->_array_size;
1139         node = &_tmp4_[_tmp5_ % _tmp6_];
1140         while (TRUE) {
1141                 gboolean _tmp7_ = FALSE;
1142                 GeeHashMapNode** _tmp8_;
1143                 gboolean _tmp20_;
1144                 GeeHashMapNode** _tmp21_;
1145                 _tmp8_ = node;
1146                 if ((*_tmp8_) != NULL) {
1147                         gboolean _tmp9_ = FALSE;
1148                         guint _tmp10_;
1149                         GeeHashMapNode** _tmp11_;
1150                         guint _tmp12_;
1151                         gboolean _tmp19_;
1152                         _tmp10_ = hash_value;
1153                         _tmp11_ = node;
1154                         _tmp12_ = (*_tmp11_)->key_hash;
1155                         if (_tmp10_ != _tmp12_) {
1156                                 _tmp9_ = TRUE;
1157                         } else {
1158                                 GeeEqualDataFunc _tmp13_;
1159                                 void* _tmp13__target;
1160                                 GeeEqualDataFunc _tmp14_;
1161                                 void* _tmp14__target;
1162                                 GeeHashMapNode** _tmp15_;
1163                                 gconstpointer _tmp16_;
1164                                 gconstpointer _tmp17_;
1165                                 gboolean _tmp18_ = FALSE;
1166                                 _tmp13_ = gee_hash_map_get_key_equal_func (self, &_tmp13__target);
1167                                 _tmp14_ = _tmp13_;
1168                                 _tmp14__target = _tmp13__target;
1169                                 _tmp15_ = node;
1170                                 _tmp16_ = (*_tmp15_)->key;
1171                                 _tmp17_ = key;
1172                                 _tmp18_ = _tmp14_ (_tmp16_, _tmp17_, _tmp14__target);
1173                                 _tmp9_ = !_tmp18_;
1174                         }
1175                         _tmp19_ = _tmp9_;
1176                         _tmp7_ = _tmp19_;
1177                 } else {
1178                         _tmp7_ = FALSE;
1179                 }
1180                 _tmp20_ = _tmp7_;
1181                 if (!_tmp20_) {
1182                         break;
1183                 }
1184                 _tmp21_ = node;
1185                 node = &(*_tmp21_)->next;
1186         }
1187         _tmp22_ = node;
1188         result = _tmp22_;
1189         return result;
1190 }
1191
1192
1193 /**
1194  * {@inheritDoc}
1195  */
1196 static gboolean gee_hash_map_real_has_key (GeeAbstractMap* base, gconstpointer key) {
1197         GeeHashMap * self;
1198         gboolean result = FALSE;
1199         gconstpointer _tmp0_;
1200         GeeHashMapNode** _tmp1_ = NULL;
1201         GeeHashMapNode** node;
1202         self = (GeeHashMap*) base;
1203         _tmp0_ = key;
1204         _tmp1_ = gee_hash_map_lookup_node (self, _tmp0_);
1205         node = _tmp1_;
1206         result = (*node) != NULL;
1207         return result;
1208 }
1209
1210
1211 /**
1212  * {@inheritDoc}
1213  */
1214 static gboolean gee_hash_map_real_has (GeeAbstractMap* base, gconstpointer key, gconstpointer value) {
1215         GeeHashMap * self;
1216         gboolean result = FALSE;
1217         gconstpointer _tmp0_;
1218         GeeHashMapNode** _tmp1_ = NULL;
1219         GeeHashMapNode** node;
1220         gboolean _tmp2_ = FALSE;
1221         GeeHashMapNode** _tmp3_;
1222         gboolean _tmp10_;
1223         self = (GeeHashMap*) base;
1224         _tmp0_ = key;
1225         _tmp1_ = gee_hash_map_lookup_node (self, _tmp0_);
1226         node = _tmp1_;
1227         _tmp3_ = node;
1228         if ((*_tmp3_) != NULL) {
1229                 GeeEqualDataFunc _tmp4_;
1230                 void* _tmp4__target;
1231                 GeeEqualDataFunc _tmp5_;
1232                 void* _tmp5__target;
1233                 GeeHashMapNode** _tmp6_;
1234                 gconstpointer _tmp7_;
1235                 gconstpointer _tmp8_;
1236                 gboolean _tmp9_ = FALSE;
1237                 _tmp4_ = gee_hash_map_get_value_equal_func (self, &_tmp4__target);
1238                 _tmp5_ = _tmp4_;
1239                 _tmp5__target = _tmp4__target;
1240                 _tmp6_ = node;
1241                 _tmp7_ = (*_tmp6_)->value;
1242                 _tmp8_ = value;
1243                 _tmp9_ = _tmp5_ (_tmp7_, _tmp8_, _tmp5__target);
1244                 _tmp2_ = _tmp9_;
1245         } else {
1246                 _tmp2_ = FALSE;
1247         }
1248         _tmp10_ = _tmp2_;
1249         result = _tmp10_;
1250         return result;
1251 }
1252
1253
1254 /**
1255  * {@inheritDoc}
1256  */
1257 static gpointer gee_hash_map_real_get (GeeAbstractMap* base, gconstpointer key) {
1258         GeeHashMap * self;
1259         gpointer result = NULL;
1260         gconstpointer _tmp0_;
1261         GeeHashMapNode** _tmp1_ = NULL;
1262         GeeHashMapNode* node;
1263         GeeHashMapNode* _tmp2_;
1264         self = (GeeHashMap*) base;
1265         _tmp0_ = key;
1266         _tmp1_ = gee_hash_map_lookup_node (self, _tmp0_);
1267         node = *_tmp1_;
1268         _tmp2_ = node;
1269         if (_tmp2_ != NULL) {
1270                 GeeHashMapNode* _tmp3_;
1271                 gconstpointer _tmp4_;
1272                 gpointer _tmp5_;
1273                 _tmp3_ = node;
1274                 _tmp4_ = _tmp3_->value;
1275                 _tmp5_ = ((_tmp4_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp4_) : ((gpointer) _tmp4_);
1276                 result = _tmp5_;
1277                 return result;
1278         } else {
1279                 result = NULL;
1280                 return result;
1281         }
1282 }
1283
1284
1285 /**
1286  * {@inheritDoc}
1287  */
1288 static void gee_hash_map_real_set (GeeAbstractMap* base, gconstpointer key, gconstpointer value) {
1289         GeeHashMap * self;
1290         gconstpointer _tmp0_;
1291         GeeHashMapNode** _tmp1_ = NULL;
1292         GeeHashMapNode** node;
1293         GeeHashMapNode** _tmp2_;
1294         gint _tmp19_;
1295         self = (GeeHashMap*) base;
1296         _tmp0_ = key;
1297         _tmp1_ = gee_hash_map_lookup_node (self, _tmp0_);
1298         node = _tmp1_;
1299         _tmp2_ = node;
1300         if ((*_tmp2_) != NULL) {
1301                 GeeHashMapNode** _tmp3_;
1302                 gconstpointer _tmp4_;
1303                 gpointer _tmp5_;
1304                 _tmp3_ = node;
1305                 _tmp4_ = value;
1306                 _tmp5_ = ((_tmp4_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp4_) : ((gpointer) _tmp4_);
1307                 (((*_tmp3_)->value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : ((*_tmp3_)->value = (self->priv->v_destroy_func ((*_tmp3_)->value), NULL));
1308                 (*_tmp3_)->value = _tmp5_;
1309         } else {
1310                 GeeHashDataFunc _tmp6_;
1311                 void* _tmp6__target;
1312                 GeeHashDataFunc _tmp7_;
1313                 void* _tmp7__target;
1314                 gconstpointer _tmp8_;
1315                 guint _tmp9_ = 0U;
1316                 guint hash_value;
1317                 GeeHashMapNode** _tmp10_;
1318                 gconstpointer _tmp11_;
1319                 gpointer _tmp12_;
1320                 gconstpointer _tmp13_;
1321                 gpointer _tmp14_;
1322                 guint _tmp15_;
1323                 GeeHashMapNode* _tmp16_;
1324                 GeeHashMapNode* _tmp17_;
1325                 gint _tmp18_;
1326                 _tmp6_ = gee_hash_map_get_key_hash_func (self, &_tmp6__target);
1327                 _tmp7_ = _tmp6_;
1328                 _tmp7__target = _tmp6__target;
1329                 _tmp8_ = key;
1330                 _tmp9_ = _tmp7_ (_tmp8_, _tmp7__target);
1331                 hash_value = _tmp9_;
1332                 _tmp10_ = node;
1333                 _tmp11_ = key;
1334                 _tmp12_ = ((_tmp11_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp11_) : ((gpointer) _tmp11_);
1335                 _tmp13_ = value;
1336                 _tmp14_ = ((_tmp13_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp13_) : ((gpointer) _tmp13_);
1337                 _tmp15_ = hash_value;
1338                 _tmp16_ = gee_hash_map_node_new (_tmp12_, _tmp14_, _tmp15_);
1339                 *_tmp10_ = _tmp16_;
1340                 _tmp17_ = *_tmp10_;
1341                 _tmp18_ = self->priv->_nnodes;
1342                 self->priv->_nnodes = _tmp18_ + 1;
1343                 gee_hash_map_resize (self);
1344         }
1345         _tmp19_ = self->priv->_stamp;
1346         self->priv->_stamp = _tmp19_ + 1;
1347 }
1348
1349
1350 /**
1351  * {@inheritDoc}
1352  */
1353 static gboolean gee_hash_map_real_unset (GeeAbstractMap* base, gconstpointer key, gpointer* value) {
1354         GeeHashMap * self;
1355         gpointer _vala_value = NULL;
1356         gboolean result = FALSE;
1357         gconstpointer _tmp0_;
1358         gpointer _tmp1_ = NULL;
1359         gboolean _tmp2_ = FALSE;
1360         gboolean b;
1361         gboolean _tmp3_;
1362         self = (GeeHashMap*) base;
1363         _tmp0_ = key;
1364         _tmp2_ = gee_hash_map_unset_helper (self, _tmp0_, &_tmp1_);
1365         ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
1366         _vala_value = _tmp1_;
1367         b = _tmp2_;
1368         _tmp3_ = b;
1369         if (_tmp3_) {
1370                 gee_hash_map_resize (self);
1371         }
1372         result = b;
1373         if (value) {
1374                 *value = _vala_value;
1375         } else {
1376                 ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
1377         }
1378         return result;
1379 }
1380
1381
1382 /**
1383  * {@inheritDoc}
1384  */
1385 static void gee_hash_map_real_clear (GeeAbstractMap* base) {
1386         GeeHashMap * self;
1387         self = (GeeHashMap*) base;
1388         {
1389                 gint i;
1390                 i = 0;
1391                 {
1392                         gboolean _tmp0_;
1393                         _tmp0_ = TRUE;
1394                         while (TRUE) {
1395                                 gboolean _tmp1_;
1396                                 gint _tmp3_;
1397                                 gint _tmp4_;
1398                                 GeeHashMapNode** _tmp5_;
1399                                 gint _tmp5__length1;
1400                                 gint _tmp6_;
1401                                 GeeHashMapNode* _tmp7_;
1402                                 GeeHashMapNode* node;
1403                                 _tmp1_ = _tmp0_;
1404                                 if (!_tmp1_) {
1405                                         gint _tmp2_;
1406                                         _tmp2_ = i;
1407                                         i = _tmp2_ + 1;
1408                                 }
1409                                 _tmp0_ = FALSE;
1410                                 _tmp3_ = i;
1411                                 _tmp4_ = self->priv->_array_size;
1412                                 if (!(_tmp3_ < _tmp4_)) {
1413                                         break;
1414                                 }
1415                                 _tmp5_ = self->priv->_nodes;
1416                                 _tmp5__length1 = self->priv->_nodes_length1;
1417                                 _tmp6_ = i;
1418                                 _tmp7_ = _tmp5_[_tmp6_];
1419                                 _tmp5_[_tmp6_] = NULL;
1420                                 node = _tmp7_;
1421                                 while (TRUE) {
1422                                         GeeHashMapNode* _tmp8_;
1423                                         GeeHashMapNode* _tmp9_;
1424                                         GeeHashMapNode* _tmp10_;
1425                                         GeeHashMapNode* next;
1426                                         GeeHashMapNode* _tmp11_;
1427                                         GeeHashMapNode* _tmp12_;
1428                                         GeeHashMapNode* _tmp13_;
1429                                         _tmp8_ = node;
1430                                         if (!(_tmp8_ != NULL)) {
1431                                                 break;
1432                                         }
1433                                         _tmp9_ = node;
1434                                         _tmp10_ = _tmp9_->next;
1435                                         _tmp9_->next = NULL;
1436                                         next = _tmp10_;
1437                                         _tmp11_ = node;
1438                                         ((_tmp11_->key == NULL) || (self->priv->k_destroy_func == NULL)) ? NULL : (_tmp11_->key = (self->priv->k_destroy_func (_tmp11_->key), NULL));
1439                                         _tmp11_->key = NULL;
1440                                         _tmp12_ = node;
1441                                         ((_tmp12_->value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_tmp12_->value = (self->priv->v_destroy_func (_tmp12_->value), NULL));
1442                                         _tmp12_->value = NULL;
1443                                         _tmp13_ = next;
1444                                         next = NULL;
1445                                         _gee_hash_map_node_free0 (node);
1446                                         node = _tmp13_;
1447                                         _gee_hash_map_node_free0 (next);
1448                                 }
1449                                 _gee_hash_map_node_free0 (node);
1450                         }
1451                 }
1452         }
1453         self->priv->_nnodes = 0;
1454         gee_hash_map_resize (self);
1455 }
1456
1457
1458 /**
1459  * {@inheritDoc}
1460  */
1461 static GeeMapIterator* gee_hash_map_real_map_iterator (GeeAbstractMap* base) {
1462         GeeHashMap * self;
1463         GeeMapIterator* result = NULL;
1464         GeeHashMapMapIterator* _tmp0_;
1465         self = (GeeHashMap*) base;
1466         _tmp0_ = gee_hash_map_map_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, self);
1467         result = (GeeMapIterator*) _tmp0_;
1468         return result;
1469 }
1470
1471
1472 static inline gboolean gee_hash_map_unset_helper (GeeHashMap* self, gconstpointer key, gpointer* value) {
1473         gpointer _vala_value = NULL;
1474         gboolean result = FALSE;
1475         gconstpointer _tmp0_;
1476         GeeHashMapNode** _tmp1_ = NULL;
1477         GeeHashMapNode** node;
1478         GeeHashMapNode** _tmp2_;
1479         g_return_val_if_fail (self != NULL, FALSE);
1480         _tmp0_ = key;
1481         _tmp1_ = gee_hash_map_lookup_node (self, _tmp0_);
1482         node = _tmp1_;
1483         _tmp2_ = node;
1484         if ((*_tmp2_) != NULL) {
1485                 GeeHashMapNode** _tmp3_;
1486                 GeeHashMapNode* _tmp4_;
1487                 GeeHashMapNode* next;
1488                 GeeHashMapNode** _tmp5_;
1489                 gpointer _tmp6_;
1490                 GeeHashMapNode** _tmp7_;
1491                 GeeHashMapNode** _tmp8_;
1492                 GeeHashMapNode** _tmp9_;
1493                 GeeHashMapNode** _tmp10_;
1494                 GeeHashMapNode* _tmp11_;
1495                 GeeHashMapNode* _tmp12_;
1496                 gint _tmp13_;
1497                 gint _tmp14_;
1498                 _tmp3_ = node;
1499                 _tmp4_ = (*_tmp3_)->next;
1500                 (*_tmp3_)->next = NULL;
1501                 next = _tmp4_;
1502                 _tmp5_ = node;
1503                 _tmp6_ = (*_tmp5_)->value;
1504                 (*_tmp5_)->value = NULL;
1505                 ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
1506                 _vala_value = _tmp6_;
1507                 _tmp7_ = node;
1508                 (((*_tmp7_)->key == NULL) || (self->priv->k_destroy_func == NULL)) ? NULL : ((*_tmp7_)->key = (self->priv->k_destroy_func ((*_tmp7_)->key), NULL));
1509                 (*_tmp7_)->key = NULL;
1510                 _tmp8_ = node;
1511                 (((*_tmp8_)->value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : ((*_tmp8_)->value = (self->priv->v_destroy_func ((*_tmp8_)->value), NULL));
1512                 (*_tmp8_)->value = NULL;
1513                 _tmp9_ = node;
1514                 gee_hash_map_node_free (*_tmp9_);
1515                 _tmp10_ = node;
1516                 _tmp11_ = next;
1517                 next = NULL;
1518                 *_tmp10_ = _tmp11_;
1519                 _tmp12_ = *_tmp10_;
1520                 _tmp13_ = self->priv->_nnodes;
1521                 self->priv->_nnodes = _tmp13_ - 1;
1522                 _tmp14_ = self->priv->_stamp;
1523                 self->priv->_stamp = _tmp14_ + 1;
1524                 result = TRUE;
1525                 _gee_hash_map_node_free0 (next);
1526                 if (value) {
1527                         *value = _vala_value;
1528                 } else {
1529                         ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
1530                 }
1531                 return result;
1532         } else {
1533                 ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
1534                 _vala_value = NULL;
1535         }
1536         result = FALSE;
1537         if (value) {
1538                 *value = _vala_value;
1539         } else {
1540                 ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
1541         }
1542         return result;
1543 }
1544
1545
1546 static inline void gee_hash_map_resize (GeeHashMap* self) {
1547         gboolean _tmp0_ = FALSE;
1548         gboolean _tmp1_ = FALSE;
1549         gint _tmp2_;
1550         gint _tmp3_;
1551         gboolean _tmp5_;
1552         gboolean _tmp11_;
1553         g_return_if_fail (self != NULL);
1554         _tmp2_ = self->priv->_array_size;
1555         _tmp3_ = self->priv->_nnodes;
1556         if (_tmp2_ >= (3 * _tmp3_)) {
1557                 gint _tmp4_;
1558                 _tmp4_ = self->priv->_array_size;
1559                 _tmp1_ = _tmp4_ >= GEE_HASH_MAP_MIN_SIZE;
1560         } else {
1561                 _tmp1_ = FALSE;
1562         }
1563         _tmp5_ = _tmp1_;
1564         if (_tmp5_) {
1565                 _tmp0_ = TRUE;
1566         } else {
1567                 gboolean _tmp6_ = FALSE;
1568                 gint _tmp7_;
1569                 gint _tmp8_;
1570                 gboolean _tmp10_;
1571                 _tmp7_ = self->priv->_array_size;
1572                 _tmp8_ = self->priv->_nnodes;
1573                 if ((3 * _tmp7_) <= _tmp8_) {
1574                         gint _tmp9_;
1575                         _tmp9_ = self->priv->_array_size;
1576                         _tmp6_ = _tmp9_ < GEE_HASH_MAP_MAX_SIZE;
1577                 } else {
1578                         _tmp6_ = FALSE;
1579                 }
1580                 _tmp10_ = _tmp6_;
1581                 _tmp0_ = _tmp10_;
1582         }
1583         _tmp11_ = _tmp0_;
1584         if (_tmp11_) {
1585                 gint _tmp12_;
1586                 guint _tmp13_ = 0U;
1587                 gint new_array_size;
1588                 gint _tmp14_;
1589                 gint _tmp15_ = 0;
1590                 gint _tmp16_;
1591                 GeeHashMapNode** _tmp17_ = NULL;
1592                 GeeHashMapNode** new_nodes;
1593                 gint new_nodes_length1;
1594                 gint _new_nodes_size_;
1595                 GeeHashMapNode** _tmp43_;
1596                 gint _tmp43__length1;
1597                 gint _tmp44_;
1598                 _tmp12_ = self->priv->_nnodes;
1599                 _tmp13_ = g_spaced_primes_closest ((guint) _tmp12_);
1600                 new_array_size = (gint) _tmp13_;
1601                 _tmp14_ = new_array_size;
1602                 _tmp15_ = CLAMP (_tmp14_, GEE_HASH_MAP_MIN_SIZE, GEE_HASH_MAP_MAX_SIZE);
1603                 new_array_size = _tmp15_;
1604                 _tmp16_ = new_array_size;
1605                 _tmp17_ = g_new0 (GeeHashMapNode*, _tmp16_ + 1);
1606                 new_nodes = _tmp17_;
1607                 new_nodes_length1 = _tmp16_;
1608                 _new_nodes_size_ = new_nodes_length1;
1609                 {
1610                         gint i;
1611                         i = 0;
1612                         {
1613                                 gboolean _tmp18_;
1614                                 _tmp18_ = TRUE;
1615                                 while (TRUE) {
1616                                         gboolean _tmp19_;
1617                                         gint _tmp21_;
1618                                         gint _tmp22_;
1619                                         GeeHashMapNode* node = NULL;
1620                                         GeeHashMapNode* next;
1621                                         _tmp19_ = _tmp18_;
1622                                         if (!_tmp19_) {
1623                                                 gint _tmp20_;
1624                                                 _tmp20_ = i;
1625                                                 i = _tmp20_ + 1;
1626                                         }
1627                                         _tmp18_ = FALSE;
1628                                         _tmp21_ = i;
1629                                         _tmp22_ = self->priv->_array_size;
1630                                         if (!(_tmp21_ < _tmp22_)) {
1631                                                 break;
1632                                         }
1633                                         next = NULL;
1634                                         {
1635                                                 GeeHashMapNode** _tmp23_;
1636                                                 gint _tmp23__length1;
1637                                                 gint _tmp24_;
1638                                                 GeeHashMapNode* _tmp25_;
1639                                                 gboolean _tmp26_;
1640                                                 _tmp23_ = self->priv->_nodes;
1641                                                 _tmp23__length1 = self->priv->_nodes_length1;
1642                                                 _tmp24_ = i;
1643                                                 _tmp25_ = _tmp23_[_tmp24_];
1644                                                 _tmp23_[_tmp24_] = NULL;
1645                                                 _gee_hash_map_node_free0 (node);
1646                                                 node = _tmp25_;
1647                                                 _tmp26_ = TRUE;
1648                                                 while (TRUE) {
1649                                                         gboolean _tmp27_;
1650                                                         GeeHashMapNode* _tmp29_;
1651                                                         GeeHashMapNode* _tmp30_;
1652                                                         GeeHashMapNode* _tmp31_;
1653                                                         GeeHashMapNode* _tmp32_;
1654                                                         guint _tmp33_;
1655                                                         gint _tmp34_;
1656                                                         guint hash_val;
1657                                                         GeeHashMapNode* _tmp35_;
1658                                                         GeeHashMapNode** _tmp36_;
1659                                                         gint _tmp36__length1;
1660                                                         guint _tmp37_;
1661                                                         GeeHashMapNode* _tmp38_;
1662                                                         GeeHashMapNode** _tmp39_;
1663                                                         gint _tmp39__length1;
1664                                                         guint _tmp40_;
1665                                                         GeeHashMapNode* _tmp41_;
1666                                                         GeeHashMapNode* _tmp42_;
1667                                                         _tmp27_ = _tmp26_;
1668                                                         if (!_tmp27_) {
1669                                                                 GeeHashMapNode* _tmp28_;
1670                                                                 _tmp28_ = next;
1671                                                                 next = NULL;
1672                                                                 _gee_hash_map_node_free0 (node);
1673                                                                 node = _tmp28_;
1674                                                         }
1675                                                         _tmp26_ = FALSE;
1676                                                         _tmp29_ = node;
1677                                                         if (!(_tmp29_ != NULL)) {
1678                                                                 break;
1679                                                         }
1680                                                         _tmp30_ = node;
1681                                                         _tmp31_ = _tmp30_->next;
1682                                                         _tmp30_->next = NULL;
1683                                                         _gee_hash_map_node_free0 (next);
1684                                                         next = _tmp31_;
1685                                                         _tmp32_ = node;
1686                                                         _tmp33_ = _tmp32_->key_hash;
1687                                                         _tmp34_ = new_array_size;
1688                                                         hash_val = _tmp33_ % _tmp34_;
1689                                                         _tmp35_ = node;
1690                                                         _tmp36_ = new_nodes;
1691                                                         _tmp36__length1 = new_nodes_length1;
1692                                                         _tmp37_ = hash_val;
1693                                                         _tmp38_ = _tmp36_[_tmp37_];
1694                                                         _tmp36_[_tmp37_] = NULL;
1695                                                         _gee_hash_map_node_free0 (_tmp35_->next);
1696                                                         _tmp35_->next = _tmp38_;
1697                                                         _tmp39_ = new_nodes;
1698                                                         _tmp39__length1 = new_nodes_length1;
1699                                                         _tmp40_ = hash_val;
1700                                                         _tmp41_ = node;
1701                                                         node = NULL;
1702                                                         _gee_hash_map_node_free0 (_tmp39_[_tmp40_]);
1703                                                         _tmp39_[_tmp40_] = _tmp41_;
1704                                                         _tmp42_ = _tmp39_[_tmp40_];
1705                                                 }
1706                                         }
1707                                         _gee_hash_map_node_free0 (next);
1708                                         _gee_hash_map_node_free0 (node);
1709                                 }
1710                         }
1711                 }
1712                 _tmp43_ = new_nodes;
1713                 _tmp43__length1 = new_nodes_length1;
1714                 new_nodes = NULL;
1715                 self->priv->_nodes = (_vala_array_free (self->priv->_nodes, self->priv->_nodes_length1, (GDestroyNotify) gee_hash_map_node_free), NULL);
1716                 self->priv->_nodes = _tmp43_;
1717                 self->priv->_nodes_length1 = _tmp43__length1;
1718                 self->priv->__nodes_size_ = self->priv->_nodes_length1;
1719                 _tmp44_ = new_array_size;
1720                 self->priv->_array_size = _tmp44_;
1721                 new_nodes = (_vala_array_free (new_nodes, new_nodes_length1, (GDestroyNotify) gee_hash_map_node_free), NULL);
1722         }
1723 }
1724
1725
1726 static gint gee_hash_map_real_get_size (GeeAbstractMap* base) {
1727         gint result;
1728         GeeHashMap* self;
1729         gint _tmp0_;
1730         self = (GeeHashMap*) base;
1731         _tmp0_ = self->priv->_nnodes;
1732         result = _tmp0_;
1733         return result;
1734 }
1735
1736
1737 static gboolean gee_hash_map_real_get_read_only (GeeAbstractMap* base) {
1738         gboolean result;
1739         GeeHashMap* self;
1740         self = (GeeHashMap*) base;
1741         result = FALSE;
1742         return result;
1743 }
1744
1745
1746 static gpointer _g_object_ref0 (gpointer self) {
1747         return self ? g_object_ref (self) : NULL;
1748 }
1749
1750
1751 static GeeSet* gee_hash_map_real_get_keys (GeeAbstractMap* base) {
1752         GeeSet* result;
1753         GeeHashMap* self;
1754         GeeSet* _tmp0_;
1755         GeeSet* _tmp1_;
1756         GeeSet* keys;
1757         GeeSet* _tmp2_;
1758         self = (GeeHashMap*) base;
1759         _tmp0_ = self->priv->_keys;
1760         _tmp1_ = _g_object_ref0 (_tmp0_);
1761         keys = _tmp1_;
1762         _tmp2_ = self->priv->_keys;
1763         if (_tmp2_ == NULL) {
1764                 GeeHashMapKeySet* _tmp3_;
1765                 GeeSet* _tmp4_;
1766                 GeeSet* _tmp5_;
1767                 _tmp3_ = gee_hash_map_key_set_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, self);
1768                 _g_object_unref0 (keys);
1769                 keys = (GeeSet*) _tmp3_;
1770                 _tmp4_ = keys;
1771                 self->priv->_keys = _tmp4_;
1772                 _tmp5_ = keys;
1773                 g_object_add_weak_pointer ((GObject*) _tmp5_, (void**) (&self->priv->_keys));
1774         }
1775         result = keys;
1776         return result;
1777 }
1778
1779
1780 static GeeCollection* gee_hash_map_real_get_values (GeeAbstractMap* base) {
1781         GeeCollection* result;
1782         GeeHashMap* self;
1783         GeeCollection* _tmp0_;
1784         GeeCollection* _tmp1_;
1785         GeeCollection* values;
1786         GeeCollection* _tmp2_;
1787         self = (GeeHashMap*) base;
1788         _tmp0_ = self->priv->_values;
1789         _tmp1_ = _g_object_ref0 (_tmp0_);
1790         values = _tmp1_;
1791         _tmp2_ = self->priv->_values;
1792         if (_tmp2_ == NULL) {
1793                 GeeHashMapValueCollection* _tmp3_;
1794                 GeeCollection* _tmp4_;
1795                 GeeCollection* _tmp5_;
1796                 _tmp3_ = gee_hash_map_value_collection_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, self);
1797                 _g_object_unref0 (values);
1798                 values = (GeeCollection*) _tmp3_;
1799                 _tmp4_ = values;
1800                 self->priv->_values = _tmp4_;
1801                 _tmp5_ = values;
1802                 g_object_add_weak_pointer ((GObject*) _tmp5_, (void**) (&self->priv->_values));
1803         }
1804         result = values;
1805         return result;
1806 }
1807
1808
1809 static GeeSet* gee_hash_map_real_get_entries (GeeAbstractMap* base) {
1810         GeeSet* result;
1811         GeeHashMap* self;
1812         GeeSet* _tmp0_;
1813         GeeSet* _tmp1_;
1814         GeeSet* entries;
1815         GeeSet* _tmp2_;
1816         self = (GeeHashMap*) base;
1817         _tmp0_ = self->priv->_entries;
1818         _tmp1_ = _g_object_ref0 (_tmp0_);
1819         entries = _tmp1_;
1820         _tmp2_ = self->priv->_entries;
1821         if (_tmp2_ == NULL) {
1822                 GeeHashMapEntrySet* _tmp3_;
1823                 GeeSet* _tmp4_;
1824                 GeeSet* _tmp5_;
1825                 _tmp3_ = gee_hash_map_entry_set_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, self);
1826                 _g_object_unref0 (entries);
1827                 entries = (GeeSet*) _tmp3_;
1828                 _tmp4_ = entries;
1829                 self->priv->_entries = _tmp4_;
1830                 _tmp5_ = entries;
1831                 g_object_add_weak_pointer ((GObject*) _tmp5_, (void**) (&self->priv->_entries));
1832         }
1833         result = entries;
1834         return result;
1835 }
1836
1837
1838 GeeHashDataFunc gee_hash_map_get_key_hash_func (GeeHashMap* self, gpointer* result_target) {
1839         GeeHashDataFunc result;
1840         GeeHashDataFunc _tmp0_;
1841         void* _tmp0__target;
1842         GeeHashDataFunc _tmp1_;
1843         void* _tmp1__target;
1844         g_return_val_if_fail (self != NULL, NULL);
1845         _tmp0_ = self->priv->_key_hash_func;
1846         _tmp0__target = self->priv->_key_hash_func_target;
1847         _tmp1_ = _tmp0_;
1848         _tmp1__target = _tmp0__target;
1849         *result_target = _tmp1__target;
1850         result = _tmp1_;
1851         return result;
1852 }
1853
1854
1855 static void gee_hash_map_set_key_hash_func (GeeHashMap* self, GeeHashDataFunc value, gpointer value_target) {
1856         GeeHashDataFunc _tmp0_;
1857         void* _tmp0__target;
1858         g_return_if_fail (self != NULL);
1859         _tmp0_ = value;
1860         _tmp0__target = value_target;
1861         (self->priv->_key_hash_func_target_destroy_notify == NULL) ? NULL : (self->priv->_key_hash_func_target_destroy_notify (self->priv->_key_hash_func_target), NULL);
1862         self->priv->_key_hash_func = NULL;
1863         self->priv->_key_hash_func_target = NULL;
1864         self->priv->_key_hash_func_target_destroy_notify = NULL;
1865         self->priv->_key_hash_func = _tmp0_;
1866         self->priv->_key_hash_func_target = _tmp0__target;
1867         self->priv->_key_hash_func_target_destroy_notify = NULL;
1868 }
1869
1870
1871 GeeEqualDataFunc gee_hash_map_get_key_equal_func (GeeHashMap* self, gpointer* result_target) {
1872         GeeEqualDataFunc result;
1873         GeeEqualDataFunc _tmp0_;
1874         void* _tmp0__target;
1875         GeeEqualDataFunc _tmp1_;
1876         void* _tmp1__target;
1877         g_return_val_if_fail (self != NULL, NULL);
1878         _tmp0_ = self->priv->_key_equal_func;
1879         _tmp0__target = self->priv->_key_equal_func_target;
1880         _tmp1_ = _tmp0_;
1881         _tmp1__target = _tmp0__target;
1882         *result_target = _tmp1__target;
1883         result = _tmp1_;
1884         return result;
1885 }
1886
1887
1888 static void gee_hash_map_set_key_equal_func (GeeHashMap* self, GeeEqualDataFunc value, gpointer value_target) {
1889         GeeEqualDataFunc _tmp0_;
1890         void* _tmp0__target;
1891         g_return_if_fail (self != NULL);
1892         _tmp0_ = value;
1893         _tmp0__target = value_target;
1894         (self->priv->_key_equal_func_target_destroy_notify == NULL) ? NULL : (self->priv->_key_equal_func_target_destroy_notify (self->priv->_key_equal_func_target), NULL);
1895         self->priv->_key_equal_func = NULL;
1896         self->priv->_key_equal_func_target = NULL;
1897         self->priv->_key_equal_func_target_destroy_notify = NULL;
1898         self->priv->_key_equal_func = _tmp0_;
1899         self->priv->_key_equal_func_target = _tmp0__target;
1900         self->priv->_key_equal_func_target_destroy_notify = NULL;
1901 }
1902
1903
1904 GeeEqualDataFunc gee_hash_map_get_value_equal_func (GeeHashMap* self, gpointer* result_target) {
1905         GeeEqualDataFunc result;
1906         GeeEqualDataFunc _tmp0_;
1907         void* _tmp0__target;
1908         GeeEqualDataFunc _tmp1_;
1909         void* _tmp1__target;
1910         g_return_val_if_fail (self != NULL, NULL);
1911         _tmp0_ = self->priv->_value_equal_func;
1912         _tmp0__target = self->priv->_value_equal_func_target;
1913         _tmp1_ = _tmp0_;
1914         _tmp1__target = _tmp0__target;
1915         *result_target = _tmp1__target;
1916         result = _tmp1_;
1917         return result;
1918 }
1919
1920
1921 static void gee_hash_map_set_value_equal_func (GeeHashMap* self, GeeEqualDataFunc value, gpointer value_target) {
1922         GeeEqualDataFunc _tmp0_;
1923         void* _tmp0__target;
1924         g_return_if_fail (self != NULL);
1925         _tmp0_ = value;
1926         _tmp0__target = value_target;
1927         (self->priv->_value_equal_func_target_destroy_notify == NULL) ? NULL : (self->priv->_value_equal_func_target_destroy_notify (self->priv->_value_equal_func_target), NULL);
1928         self->priv->_value_equal_func = NULL;
1929         self->priv->_value_equal_func_target = NULL;
1930         self->priv->_value_equal_func_target_destroy_notify = NULL;
1931         self->priv->_value_equal_func = _tmp0_;
1932         self->priv->_value_equal_func_target = _tmp0__target;
1933         self->priv->_value_equal_func_target_destroy_notify = NULL;
1934 }
1935
1936
1937 static GeeHashMapNode* gee_hash_map_node_new (gpointer k, gpointer v, guint hash) {
1938         GeeHashMapNode* self;
1939         gpointer _tmp0_;
1940         gpointer _tmp1_;
1941         guint _tmp2_;
1942         self = g_slice_new0 (GeeHashMapNode);
1943         gee_hash_map_node_instance_init (self);
1944         _tmp0_ = k;
1945         k = NULL;
1946         self->key = _tmp0_;
1947         _tmp1_ = v;
1948         v = NULL;
1949         self->value = _tmp1_;
1950         _tmp2_ = hash;
1951         self->key_hash = _tmp2_;
1952         self->entry = NULL;
1953         return self;
1954 }
1955
1956
1957 static void gee_hash_map_node_instance_init (GeeHashMapNode * self) {
1958 }
1959
1960
1961 static void gee_hash_map_node_free (GeeHashMapNode* self) {
1962         _gee_hash_map_node_free0 (self->next);
1963         g_slice_free (GeeHashMapNode, self);
1964 }
1965
1966
1967 static GeeMapEntry* gee_hash_map_entry_entry_for (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMapNode* node) {
1968         GeeMapEntry* result = NULL;
1969         GeeHashMapNode* _tmp0_;
1970         GeeMapEntry* _tmp1_;
1971         GeeMapEntry* _tmp2_;
1972         GeeMapEntry* _result_;
1973         GeeHashMapNode* _tmp3_;
1974         GeeMapEntry* _tmp4_;
1975         g_return_val_if_fail (node != NULL, NULL);
1976         _tmp0_ = node;
1977         _tmp1_ = _tmp0_->entry;
1978         _tmp2_ = _g_object_ref0 (_tmp1_);
1979         _result_ = _tmp2_;
1980         _tmp3_ = node;
1981         _tmp4_ = _tmp3_->entry;
1982         if (_tmp4_ == NULL) {
1983                 GeeHashMapNode* _tmp5_;
1984                 GeeHashMapEntry* _tmp6_;
1985                 GeeHashMapNode* _tmp7_;
1986                 GeeMapEntry* _tmp8_;
1987                 GeeMapEntry* _tmp9_;
1988                 GeeHashMapNode* _tmp10_;
1989                 _tmp5_ = node;
1990                 _tmp6_ = gee_hash_map_entry_new (k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp5_);
1991                 _g_object_unref0 (_result_);
1992                 _result_ = (GeeMapEntry*) _tmp6_;
1993                 _tmp7_ = node;
1994                 _tmp8_ = _result_;
1995                 _tmp7_->entry = _tmp8_;
1996                 _tmp9_ = _result_;
1997                 _tmp10_ = node;
1998                 g_object_add_weak_pointer ((GObject*) _tmp9_, (void**) (&_tmp10_->entry));
1999         }
2000         result = _result_;
2001         return result;
2002 }
2003
2004
2005 static GeeHashMapEntry* gee_hash_map_entry_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMapNode* node) {
2006         GeeHashMapEntry * self = NULL;
2007         GeeHashMapNode* _tmp0_;
2008         g_return_val_if_fail (node != NULL, NULL);
2009         self = (GeeHashMapEntry*) gee_map_entry_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func);
2010         self->priv->k_type = k_type;
2011         self->priv->k_dup_func = k_dup_func;
2012         self->priv->k_destroy_func = k_destroy_func;
2013         self->priv->v_type = v_type;
2014         self->priv->v_dup_func = v_dup_func;
2015         self->priv->v_destroy_func = v_destroy_func;
2016         _tmp0_ = node;
2017         self->priv->_node = _tmp0_;
2018         return self;
2019 }
2020
2021
2022 static GeeHashMapEntry* gee_hash_map_entry_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMapNode* node) {
2023         return gee_hash_map_entry_construct (GEE_HASH_MAP_TYPE_ENTRY, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, node);
2024 }
2025
2026
2027 static gconstpointer gee_hash_map_entry_real_get_key (GeeMapEntry* base) {
2028         gconstpointer result;
2029         GeeHashMapEntry* self;
2030         GeeHashMapNode* _tmp0_;
2031         gconstpointer _tmp1_;
2032         self = (GeeHashMapEntry*) base;
2033         _tmp0_ = self->priv->_node;
2034         _tmp1_ = _tmp0_->key;
2035         result = _tmp1_;
2036         return result;
2037 }
2038
2039
2040 static gconstpointer gee_hash_map_entry_real_get_value (GeeMapEntry* base) {
2041         gconstpointer result;
2042         GeeHashMapEntry* self;
2043         GeeHashMapNode* _tmp0_;
2044         gconstpointer _tmp1_;
2045         self = (GeeHashMapEntry*) base;
2046         _tmp0_ = self->priv->_node;
2047         _tmp1_ = _tmp0_->value;
2048         result = _tmp1_;
2049         return result;
2050 }
2051
2052
2053 static void gee_hash_map_entry_real_set_value (GeeMapEntry* base, gconstpointer value) {
2054         GeeHashMapEntry* self;
2055         GeeHashMapNode* _tmp0_;
2056         gconstpointer _tmp1_;
2057         gpointer _tmp2_;
2058         self = (GeeHashMapEntry*) base;
2059         _tmp0_ = self->priv->_node;
2060         _tmp1_ = value;
2061         _tmp2_ = ((_tmp1_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp1_) : ((gpointer) _tmp1_);
2062         ((_tmp0_->value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_tmp0_->value = (self->priv->v_destroy_func (_tmp0_->value), NULL));
2063         _tmp0_->value = _tmp2_;
2064         g_object_notify ((GObject *) self, "value");
2065 }
2066
2067
2068 static gboolean gee_hash_map_entry_real_get_read_only (GeeMapEntry* base) {
2069         gboolean result;
2070         GeeHashMapEntry* self;
2071         self = (GeeHashMapEntry*) base;
2072         result = FALSE;
2073         return result;
2074 }
2075
2076
2077 static void gee_hash_map_entry_class_init (GeeHashMapEntryClass * klass) {
2078         gee_hash_map_entry_parent_class = g_type_class_peek_parent (klass);
2079         g_type_class_add_private (klass, sizeof (GeeHashMapEntryPrivate));
2080         GEE_MAP_ENTRY_CLASS (klass)->get_key = gee_hash_map_entry_real_get_key;
2081         GEE_MAP_ENTRY_CLASS (klass)->get_value = gee_hash_map_entry_real_get_value;
2082         GEE_MAP_ENTRY_CLASS (klass)->set_value = gee_hash_map_entry_real_set_value;
2083         GEE_MAP_ENTRY_CLASS (klass)->get_read_only = gee_hash_map_entry_real_get_read_only;
2084         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_entry_get_property;
2085         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_entry_set_property;
2086         G_OBJECT_CLASS (klass)->finalize = gee_hash_map_entry_finalize;
2087         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_K_TYPE, g_param_spec_gtype ("k-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));
2088         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_K_DUP_FUNC, g_param_spec_pointer ("k-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));
2089         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
2090         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_V_TYPE, g_param_spec_gtype ("v-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));
2091         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_V_DUP_FUNC, g_param_spec_pointer ("v-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));
2092         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
2093         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_KEY, g_param_spec_pointer ("key", "key", "key", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2094         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_VALUE, g_param_spec_pointer ("value", "value", "value", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
2095         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_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));
2096 }
2097
2098
2099 static void gee_hash_map_entry_instance_init (GeeHashMapEntry * self) {
2100         self->priv = GEE_HASH_MAP_ENTRY_GET_PRIVATE (self);
2101 }
2102
2103
2104 static void gee_hash_map_entry_finalize (GObject* obj) {
2105         GeeHashMapEntry * self;
2106         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_HASH_MAP_TYPE_ENTRY, GeeHashMapEntry);
2107         G_OBJECT_CLASS (gee_hash_map_entry_parent_class)->finalize (obj);
2108 }
2109
2110
2111 static GType gee_hash_map_entry_get_type (void) {
2112         static volatile gsize gee_hash_map_entry_type_id__volatile = 0;
2113         if (g_once_init_enter (&gee_hash_map_entry_type_id__volatile)) {
2114                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapEntryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_entry_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapEntry), 0, (GInstanceInitFunc) gee_hash_map_entry_instance_init, NULL };
2115                 GType gee_hash_map_entry_type_id;
2116                 gee_hash_map_entry_type_id = g_type_register_static (GEE_MAP_TYPE_ENTRY, "GeeHashMapEntry", &g_define_type_info, 0);
2117                 g_once_init_leave (&gee_hash_map_entry_type_id__volatile, gee_hash_map_entry_type_id);
2118         }
2119         return gee_hash_map_entry_type_id__volatile;
2120 }
2121
2122
2123 static void _vala_gee_hash_map_entry_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2124         GeeHashMapEntry * self;
2125         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_ENTRY, GeeHashMapEntry);
2126         switch (property_id) {
2127                 case GEE_HASH_MAP_ENTRY_KEY:
2128                 g_value_set_pointer (value, gee_map_entry_get_key ((GeeMapEntry*) self));
2129                 break;
2130                 case GEE_HASH_MAP_ENTRY_VALUE:
2131                 g_value_set_pointer (value, gee_map_entry_get_value ((GeeMapEntry*) self));
2132                 break;
2133                 case GEE_HASH_MAP_ENTRY_READ_ONLY:
2134                 g_value_set_boolean (value, gee_map_entry_get_read_only ((GeeMapEntry*) self));
2135                 break;
2136                 default:
2137                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2138                 break;
2139         }
2140 }
2141
2142
2143 static void _vala_gee_hash_map_entry_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2144         GeeHashMapEntry * self;
2145         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_ENTRY, GeeHashMapEntry);
2146         switch (property_id) {
2147                 case GEE_HASH_MAP_ENTRY_VALUE:
2148                 gee_map_entry_set_value ((GeeMapEntry*) self, g_value_get_pointer (value));
2149                 break;
2150                 case GEE_HASH_MAP_ENTRY_K_TYPE:
2151                 self->priv->k_type = g_value_get_gtype (value);
2152                 break;
2153                 case GEE_HASH_MAP_ENTRY_K_DUP_FUNC:
2154                 self->priv->k_dup_func = g_value_get_pointer (value);
2155                 break;
2156                 case GEE_HASH_MAP_ENTRY_K_DESTROY_FUNC:
2157                 self->priv->k_destroy_func = g_value_get_pointer (value);
2158                 break;
2159                 case GEE_HASH_MAP_ENTRY_V_TYPE:
2160                 self->priv->v_type = g_value_get_gtype (value);
2161                 break;
2162                 case GEE_HASH_MAP_ENTRY_V_DUP_FUNC:
2163                 self->priv->v_dup_func = g_value_get_pointer (value);
2164                 break;
2165                 case GEE_HASH_MAP_ENTRY_V_DESTROY_FUNC:
2166                 self->priv->v_destroy_func = g_value_get_pointer (value);
2167                 break;
2168                 default:
2169                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2170                 break;
2171         }
2172 }
2173
2174
2175 static GeeHashMapKeySet* gee_hash_map_key_set_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
2176         GeeHashMapKeySet * self = NULL;
2177         GeeHashMap* _tmp0_;
2178         GeeHashMap* _tmp1_;
2179         g_return_val_if_fail (map != NULL, NULL);
2180         self = (GeeHashMapKeySet*) gee_abstract_set_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func);
2181         self->priv->k_type = k_type;
2182         self->priv->k_dup_func = k_dup_func;
2183         self->priv->k_destroy_func = k_destroy_func;
2184         self->priv->v_type = v_type;
2185         self->priv->v_dup_func = v_dup_func;
2186         self->priv->v_destroy_func = v_destroy_func;
2187         _tmp0_ = map;
2188         _tmp1_ = _g_object_ref0 (_tmp0_);
2189         _g_object_unref0 (self->priv->_map);
2190         self->priv->_map = _tmp1_;
2191         return self;
2192 }
2193
2194
2195 static GeeHashMapKeySet* gee_hash_map_key_set_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
2196         return gee_hash_map_key_set_construct (GEE_HASH_MAP_TYPE_KEY_SET, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
2197 }
2198
2199
2200 static GeeIterator* gee_hash_map_key_set_real_iterator (GeeAbstractCollection* base) {
2201         GeeHashMapKeySet * self;
2202         GeeIterator* result = NULL;
2203         GeeHashMap* _tmp0_;
2204         GeeHashMapKeyIterator* _tmp1_;
2205         self = (GeeHashMapKeySet*) base;
2206         _tmp0_ = self->priv->_map;
2207         _tmp1_ = gee_hash_map_key_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp0_);
2208         result = (GeeIterator*) _tmp1_;
2209         return result;
2210 }
2211
2212
2213 static gboolean gee_hash_map_key_set_real_add (GeeAbstractCollection* base, gconstpointer key) {
2214         GeeHashMapKeySet * self;
2215         gboolean result = FALSE;
2216         self = (GeeHashMapKeySet*) base;
2217         g_assert_not_reached ();
2218         return result;
2219 }
2220
2221
2222 static void gee_hash_map_key_set_real_clear (GeeAbstractCollection* base) {
2223         GeeHashMapKeySet * self;
2224         self = (GeeHashMapKeySet*) base;
2225         g_assert_not_reached ();
2226 }
2227
2228
2229 static gboolean gee_hash_map_key_set_real_remove (GeeAbstractCollection* base, gconstpointer key) {
2230         GeeHashMapKeySet * self;
2231         gboolean result = FALSE;
2232         self = (GeeHashMapKeySet*) base;
2233         g_assert_not_reached ();
2234         return result;
2235 }
2236
2237
2238 static gboolean gee_hash_map_key_set_real_contains (GeeAbstractCollection* base, gconstpointer key) {
2239         GeeHashMapKeySet * self;
2240         gboolean result = FALSE;
2241         GeeHashMap* _tmp0_;
2242         gconstpointer _tmp1_;
2243         gboolean _tmp2_ = FALSE;
2244         self = (GeeHashMapKeySet*) base;
2245         _tmp0_ = self->priv->_map;
2246         _tmp1_ = key;
2247         _tmp2_ = gee_abstract_map_has_key ((GeeAbstractMap*) _tmp0_, _tmp1_);
2248         result = _tmp2_;
2249         return result;
2250 }
2251
2252
2253 static gboolean gee_hash_map_key_set_add_all (GeeHashMapKeySet* self, GeeCollection* collection) {
2254         gboolean result = FALSE;
2255         g_return_val_if_fail (self != NULL, FALSE);
2256         g_return_val_if_fail (collection != NULL, FALSE);
2257         g_assert_not_reached ();
2258         return result;
2259 }
2260
2261
2262 static gboolean gee_hash_map_key_set_remove_all (GeeHashMapKeySet* self, GeeCollection* collection) {
2263         gboolean result = FALSE;
2264         g_return_val_if_fail (self != NULL, FALSE);
2265         g_return_val_if_fail (collection != NULL, FALSE);
2266         g_assert_not_reached ();
2267         return result;
2268 }
2269
2270
2271 static gboolean gee_hash_map_key_set_retain_all (GeeHashMapKeySet* self, GeeCollection* collection) {
2272         gboolean result = FALSE;
2273         g_return_val_if_fail (self != NULL, FALSE);
2274         g_return_val_if_fail (collection != NULL, FALSE);
2275         g_assert_not_reached ();
2276         return result;
2277 }
2278
2279
2280 static gint gee_hash_map_key_set_real_get_size (GeeAbstractCollection* base) {
2281         gint result;
2282         GeeHashMapKeySet* self;
2283         GeeHashMap* _tmp0_;
2284         gint _tmp1_;
2285         gint _tmp2_;
2286         self = (GeeHashMapKeySet*) base;
2287         _tmp0_ = self->priv->_map;
2288         _tmp1_ = gee_abstract_map_get_size ((GeeMap*) _tmp0_);
2289         _tmp2_ = _tmp1_;
2290         result = _tmp2_;
2291         return result;
2292 }
2293
2294
2295 static gboolean gee_hash_map_key_set_real_get_read_only (GeeAbstractCollection* base) {
2296         gboolean result;
2297         GeeHashMapKeySet* self;
2298         self = (GeeHashMapKeySet*) base;
2299         result = TRUE;
2300         return result;
2301 }
2302
2303
2304 static void gee_hash_map_key_set_class_init (GeeHashMapKeySetClass * klass) {
2305         gee_hash_map_key_set_parent_class = g_type_class_peek_parent (klass);
2306         g_type_class_add_private (klass, sizeof (GeeHashMapKeySetPrivate));
2307         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_hash_map_key_set_real_iterator;
2308         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_hash_map_key_set_real_add;
2309         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_hash_map_key_set_real_clear;
2310         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_hash_map_key_set_real_remove;
2311         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_hash_map_key_set_real_contains;
2312         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_hash_map_key_set_real_get_size;
2313         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_hash_map_key_set_real_get_read_only;
2314         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_key_set_get_property;
2315         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_key_set_set_property;
2316         G_OBJECT_CLASS (klass)->finalize = gee_hash_map_key_set_finalize;
2317         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_K_TYPE, g_param_spec_gtype ("k-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));
2318         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_K_DUP_FUNC, g_param_spec_pointer ("k-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));
2319         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
2320         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_V_TYPE, g_param_spec_gtype ("v-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));
2321         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_V_DUP_FUNC, g_param_spec_pointer ("v-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));
2322         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
2323         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2324         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_SET_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2325 }
2326
2327
2328 static void gee_hash_map_key_set_instance_init (GeeHashMapKeySet * self) {
2329         self->priv = GEE_HASH_MAP_KEY_SET_GET_PRIVATE (self);
2330 }
2331
2332
2333 static void gee_hash_map_key_set_finalize (GObject* obj) {
2334         GeeHashMapKeySet * self;
2335         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_HASH_MAP_TYPE_KEY_SET, GeeHashMapKeySet);
2336         _g_object_unref0 (self->priv->_map);
2337         G_OBJECT_CLASS (gee_hash_map_key_set_parent_class)->finalize (obj);
2338 }
2339
2340
2341 static GType gee_hash_map_key_set_get_type (void) {
2342         static volatile gsize gee_hash_map_key_set_type_id__volatile = 0;
2343         if (g_once_init_enter (&gee_hash_map_key_set_type_id__volatile)) {
2344                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapKeySetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_key_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapKeySet), 0, (GInstanceInitFunc) gee_hash_map_key_set_instance_init, NULL };
2345                 GType gee_hash_map_key_set_type_id;
2346                 gee_hash_map_key_set_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_SET, "GeeHashMapKeySet", &g_define_type_info, 0);
2347                 g_once_init_leave (&gee_hash_map_key_set_type_id__volatile, gee_hash_map_key_set_type_id);
2348         }
2349         return gee_hash_map_key_set_type_id__volatile;
2350 }
2351
2352
2353 static void _vala_gee_hash_map_key_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2354         GeeHashMapKeySet * self;
2355         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_KEY_SET, GeeHashMapKeySet);
2356         switch (property_id) {
2357                 case GEE_HASH_MAP_KEY_SET_SIZE:
2358                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
2359                 break;
2360                 case GEE_HASH_MAP_KEY_SET_READ_ONLY:
2361                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
2362                 break;
2363                 default:
2364                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2365                 break;
2366         }
2367 }
2368
2369
2370 static void _vala_gee_hash_map_key_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2371         GeeHashMapKeySet * self;
2372         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_KEY_SET, GeeHashMapKeySet);
2373         switch (property_id) {
2374                 case GEE_HASH_MAP_KEY_SET_K_TYPE:
2375                 self->priv->k_type = g_value_get_gtype (value);
2376                 break;
2377                 case GEE_HASH_MAP_KEY_SET_K_DUP_FUNC:
2378                 self->priv->k_dup_func = g_value_get_pointer (value);
2379                 break;
2380                 case GEE_HASH_MAP_KEY_SET_K_DESTROY_FUNC:
2381                 self->priv->k_destroy_func = g_value_get_pointer (value);
2382                 break;
2383                 case GEE_HASH_MAP_KEY_SET_V_TYPE:
2384                 self->priv->v_type = g_value_get_gtype (value);
2385                 break;
2386                 case GEE_HASH_MAP_KEY_SET_V_DUP_FUNC:
2387                 self->priv->v_dup_func = g_value_get_pointer (value);
2388                 break;
2389                 case GEE_HASH_MAP_KEY_SET_V_DESTROY_FUNC:
2390                 self->priv->v_destroy_func = g_value_get_pointer (value);
2391                 break;
2392                 default:
2393                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2394                 break;
2395         }
2396 }
2397
2398
2399 static GeeHashMapValueCollection* gee_hash_map_value_collection_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
2400         GeeHashMapValueCollection * self = NULL;
2401         GeeHashMap* _tmp0_;
2402         GeeHashMap* _tmp1_;
2403         g_return_val_if_fail (map != NULL, NULL);
2404         self = (GeeHashMapValueCollection*) gee_abstract_collection_construct (object_type, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func);
2405         self->priv->k_type = k_type;
2406         self->priv->k_dup_func = k_dup_func;
2407         self->priv->k_destroy_func = k_destroy_func;
2408         self->priv->v_type = v_type;
2409         self->priv->v_dup_func = v_dup_func;
2410         self->priv->v_destroy_func = v_destroy_func;
2411         _tmp0_ = map;
2412         _tmp1_ = _g_object_ref0 (_tmp0_);
2413         _g_object_unref0 (self->priv->_map);
2414         self->priv->_map = _tmp1_;
2415         return self;
2416 }
2417
2418
2419 static GeeHashMapValueCollection* gee_hash_map_value_collection_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
2420         return gee_hash_map_value_collection_construct (GEE_HASH_MAP_TYPE_VALUE_COLLECTION, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
2421 }
2422
2423
2424 static GeeIterator* gee_hash_map_value_collection_real_iterator (GeeAbstractCollection* base) {
2425         GeeHashMapValueCollection * self;
2426         GeeIterator* result = NULL;
2427         GeeHashMap* _tmp0_;
2428         GeeHashMapValueIterator* _tmp1_;
2429         self = (GeeHashMapValueCollection*) base;
2430         _tmp0_ = self->priv->_map;
2431         _tmp1_ = gee_hash_map_value_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp0_);
2432         result = (GeeIterator*) _tmp1_;
2433         return result;
2434 }
2435
2436
2437 static gboolean gee_hash_map_value_collection_real_add (GeeAbstractCollection* base, gconstpointer value) {
2438         GeeHashMapValueCollection * self;
2439         gboolean result = FALSE;
2440         self = (GeeHashMapValueCollection*) base;
2441         g_assert_not_reached ();
2442         return result;
2443 }
2444
2445
2446 static void gee_hash_map_value_collection_real_clear (GeeAbstractCollection* base) {
2447         GeeHashMapValueCollection * self;
2448         self = (GeeHashMapValueCollection*) base;
2449         g_assert_not_reached ();
2450 }
2451
2452
2453 static gboolean gee_hash_map_value_collection_real_remove (GeeAbstractCollection* base, gconstpointer value) {
2454         GeeHashMapValueCollection * self;
2455         gboolean result = FALSE;
2456         self = (GeeHashMapValueCollection*) base;
2457         g_assert_not_reached ();
2458         return result;
2459 }
2460
2461
2462 static gboolean gee_hash_map_value_collection_real_contains (GeeAbstractCollection* base, gconstpointer value) {
2463         GeeHashMapValueCollection * self;
2464         gboolean result = FALSE;
2465         GeeIterator* _tmp0_ = NULL;
2466         GeeIterator* it;
2467         self = (GeeHashMapValueCollection*) base;
2468         _tmp0_ = gee_abstract_collection_iterator ((GeeAbstractCollection*) self);
2469         it = _tmp0_;
2470         while (TRUE) {
2471                 GeeIterator* _tmp1_;
2472                 gboolean _tmp2_ = FALSE;
2473                 GeeHashMap* _tmp3_;
2474                 GeeEqualDataFunc _tmp4_;
2475                 void* _tmp4__target;
2476                 GeeEqualDataFunc _tmp5_;
2477                 void* _tmp5__target;
2478                 GeeIterator* _tmp6_;
2479                 gpointer _tmp7_ = NULL;
2480                 gpointer _tmp8_;
2481                 gconstpointer _tmp9_;
2482                 gboolean _tmp10_ = FALSE;
2483                 gboolean _tmp11_;
2484                 _tmp1_ = it;
2485                 _tmp2_ = gee_iterator_next (_tmp1_);
2486                 if (!_tmp2_) {
2487                         break;
2488                 }
2489                 _tmp3_ = self->priv->_map;
2490                 _tmp4_ = gee_hash_map_get_value_equal_func (_tmp3_, &_tmp4__target);
2491                 _tmp5_ = _tmp4_;
2492                 _tmp5__target = _tmp4__target;
2493                 _tmp6_ = it;
2494                 _tmp7_ = gee_iterator_get (_tmp6_);
2495                 _tmp8_ = _tmp7_;
2496                 _tmp9_ = value;
2497                 _tmp10_ = _tmp5_ (_tmp8_, _tmp9_, _tmp5__target);
2498                 _tmp11_ = _tmp10_;
2499                 ((_tmp8_ == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_tmp8_ = (self->priv->v_destroy_func (_tmp8_), NULL));
2500                 if (_tmp11_) {
2501                         result = TRUE;
2502                         _g_object_unref0 (it);
2503                         return result;
2504                 }
2505         }
2506         result = FALSE;
2507         _g_object_unref0 (it);
2508         return result;
2509 }
2510
2511
2512 static gboolean gee_hash_map_value_collection_add_all (GeeHashMapValueCollection* self, GeeCollection* collection) {
2513         gboolean result = FALSE;
2514         g_return_val_if_fail (self != NULL, FALSE);
2515         g_return_val_if_fail (collection != NULL, FALSE);
2516         g_assert_not_reached ();
2517         return result;
2518 }
2519
2520
2521 static gboolean gee_hash_map_value_collection_remove_all (GeeHashMapValueCollection* self, GeeCollection* collection) {
2522         gboolean result = FALSE;
2523         g_return_val_if_fail (self != NULL, FALSE);
2524         g_return_val_if_fail (collection != NULL, FALSE);
2525         g_assert_not_reached ();
2526         return result;
2527 }
2528
2529
2530 static gboolean gee_hash_map_value_collection_retain_all (GeeHashMapValueCollection* self, GeeCollection* collection) {
2531         gboolean result = FALSE;
2532         g_return_val_if_fail (self != NULL, FALSE);
2533         g_return_val_if_fail (collection != NULL, FALSE);
2534         g_assert_not_reached ();
2535         return result;
2536 }
2537
2538
2539 static gint gee_hash_map_value_collection_real_get_size (GeeAbstractCollection* base) {
2540         gint result;
2541         GeeHashMapValueCollection* self;
2542         GeeHashMap* _tmp0_;
2543         gint _tmp1_;
2544         gint _tmp2_;
2545         self = (GeeHashMapValueCollection*) base;
2546         _tmp0_ = self->priv->_map;
2547         _tmp1_ = gee_abstract_map_get_size ((GeeMap*) _tmp0_);
2548         _tmp2_ = _tmp1_;
2549         result = _tmp2_;
2550         return result;
2551 }
2552
2553
2554 static gboolean gee_hash_map_value_collection_real_get_read_only (GeeAbstractCollection* base) {
2555         gboolean result;
2556         GeeHashMapValueCollection* self;
2557         self = (GeeHashMapValueCollection*) base;
2558         result = TRUE;
2559         return result;
2560 }
2561
2562
2563 static void gee_hash_map_value_collection_class_init (GeeHashMapValueCollectionClass * klass) {
2564         gee_hash_map_value_collection_parent_class = g_type_class_peek_parent (klass);
2565         g_type_class_add_private (klass, sizeof (GeeHashMapValueCollectionPrivate));
2566         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_hash_map_value_collection_real_iterator;
2567         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_hash_map_value_collection_real_add;
2568         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_hash_map_value_collection_real_clear;
2569         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_hash_map_value_collection_real_remove;
2570         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_hash_map_value_collection_real_contains;
2571         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_hash_map_value_collection_real_get_size;
2572         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_hash_map_value_collection_real_get_read_only;
2573         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_value_collection_get_property;
2574         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_value_collection_set_property;
2575         G_OBJECT_CLASS (klass)->finalize = gee_hash_map_value_collection_finalize;
2576         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_K_TYPE, g_param_spec_gtype ("k-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));
2577         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_K_DUP_FUNC, g_param_spec_pointer ("k-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));
2578         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
2579         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_V_TYPE, g_param_spec_gtype ("v-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));
2580         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_V_DUP_FUNC, g_param_spec_pointer ("v-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));
2581         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
2582         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_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));
2583         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_COLLECTION_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));
2584 }
2585
2586
2587 static void gee_hash_map_value_collection_instance_init (GeeHashMapValueCollection * self) {
2588         self->priv = GEE_HASH_MAP_VALUE_COLLECTION_GET_PRIVATE (self);
2589 }
2590
2591
2592 static void gee_hash_map_value_collection_finalize (GObject* obj) {
2593         GeeHashMapValueCollection * self;
2594         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_HASH_MAP_TYPE_VALUE_COLLECTION, GeeHashMapValueCollection);
2595         _g_object_unref0 (self->priv->_map);
2596         G_OBJECT_CLASS (gee_hash_map_value_collection_parent_class)->finalize (obj);
2597 }
2598
2599
2600 static GType gee_hash_map_value_collection_get_type (void) {
2601         static volatile gsize gee_hash_map_value_collection_type_id__volatile = 0;
2602         if (g_once_init_enter (&gee_hash_map_value_collection_type_id__volatile)) {
2603                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapValueCollectionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_value_collection_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapValueCollection), 0, (GInstanceInitFunc) gee_hash_map_value_collection_instance_init, NULL };
2604                 GType gee_hash_map_value_collection_type_id;
2605                 gee_hash_map_value_collection_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_COLLECTION, "GeeHashMapValueCollection", &g_define_type_info, 0);
2606                 g_once_init_leave (&gee_hash_map_value_collection_type_id__volatile, gee_hash_map_value_collection_type_id);
2607         }
2608         return gee_hash_map_value_collection_type_id__volatile;
2609 }
2610
2611
2612 static void _vala_gee_hash_map_value_collection_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2613         GeeHashMapValueCollection * self;
2614         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_VALUE_COLLECTION, GeeHashMapValueCollection);
2615         switch (property_id) {
2616                 case GEE_HASH_MAP_VALUE_COLLECTION_SIZE:
2617                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
2618                 break;
2619                 case GEE_HASH_MAP_VALUE_COLLECTION_READ_ONLY:
2620                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
2621                 break;
2622                 default:
2623                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2624                 break;
2625         }
2626 }
2627
2628
2629 static void _vala_gee_hash_map_value_collection_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2630         GeeHashMapValueCollection * self;
2631         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_VALUE_COLLECTION, GeeHashMapValueCollection);
2632         switch (property_id) {
2633                 case GEE_HASH_MAP_VALUE_COLLECTION_K_TYPE:
2634                 self->priv->k_type = g_value_get_gtype (value);
2635                 break;
2636                 case GEE_HASH_MAP_VALUE_COLLECTION_K_DUP_FUNC:
2637                 self->priv->k_dup_func = g_value_get_pointer (value);
2638                 break;
2639                 case GEE_HASH_MAP_VALUE_COLLECTION_K_DESTROY_FUNC:
2640                 self->priv->k_destroy_func = g_value_get_pointer (value);
2641                 break;
2642                 case GEE_HASH_MAP_VALUE_COLLECTION_V_TYPE:
2643                 self->priv->v_type = g_value_get_gtype (value);
2644                 break;
2645                 case GEE_HASH_MAP_VALUE_COLLECTION_V_DUP_FUNC:
2646                 self->priv->v_dup_func = g_value_get_pointer (value);
2647                 break;
2648                 case GEE_HASH_MAP_VALUE_COLLECTION_V_DESTROY_FUNC:
2649                 self->priv->v_destroy_func = g_value_get_pointer (value);
2650                 break;
2651                 default:
2652                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2653                 break;
2654         }
2655 }
2656
2657
2658 static GeeHashMapEntrySet* gee_hash_map_entry_set_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
2659         GeeHashMapEntrySet * self = NULL;
2660         GeeHashMap* _tmp0_;
2661         GeeHashMap* _tmp1_;
2662         g_return_val_if_fail (map != NULL, NULL);
2663         self = (GeeHashMapEntrySet*) gee_abstract_set_construct (object_type, GEE_MAP_TYPE_ENTRY, (GBoxedCopyFunc) g_object_ref, g_object_unref);
2664         self->priv->k_type = k_type;
2665         self->priv->k_dup_func = k_dup_func;
2666         self->priv->k_destroy_func = k_destroy_func;
2667         self->priv->v_type = v_type;
2668         self->priv->v_dup_func = v_dup_func;
2669         self->priv->v_destroy_func = v_destroy_func;
2670         _tmp0_ = map;
2671         _tmp1_ = _g_object_ref0 (_tmp0_);
2672         _g_object_unref0 (self->priv->_map);
2673         self->priv->_map = _tmp1_;
2674         return self;
2675 }
2676
2677
2678 static GeeHashMapEntrySet* gee_hash_map_entry_set_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
2679         return gee_hash_map_entry_set_construct (GEE_HASH_MAP_TYPE_ENTRY_SET, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
2680 }
2681
2682
2683 static GeeIterator* gee_hash_map_entry_set_real_iterator (GeeAbstractCollection* base) {
2684         GeeHashMapEntrySet * self;
2685         GeeIterator* result = NULL;
2686         GeeHashMap* _tmp0_;
2687         GeeHashMapEntryIterator* _tmp1_;
2688         self = (GeeHashMapEntrySet*) base;
2689         _tmp0_ = self->priv->_map;
2690         _tmp1_ = gee_hash_map_entry_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp0_);
2691         result = (GeeIterator*) _tmp1_;
2692         return result;
2693 }
2694
2695
2696 static gboolean gee_hash_map_entry_set_real_add (GeeAbstractCollection* base, GeeMapEntry* entry) {
2697         GeeHashMapEntrySet * self;
2698         gboolean result = FALSE;
2699         self = (GeeHashMapEntrySet*) base;
2700         g_return_val_if_fail (entry != NULL, FALSE);
2701         g_assert_not_reached ();
2702         return result;
2703 }
2704
2705
2706 static void gee_hash_map_entry_set_real_clear (GeeAbstractCollection* base) {
2707         GeeHashMapEntrySet * self;
2708         self = (GeeHashMapEntrySet*) base;
2709         g_assert_not_reached ();
2710 }
2711
2712
2713 static gboolean gee_hash_map_entry_set_real_remove (GeeAbstractCollection* base, GeeMapEntry* entry) {
2714         GeeHashMapEntrySet * self;
2715         gboolean result = FALSE;
2716         self = (GeeHashMapEntrySet*) base;
2717         g_return_val_if_fail (entry != NULL, FALSE);
2718         g_assert_not_reached ();
2719         return result;
2720 }
2721
2722
2723 static gboolean gee_hash_map_entry_set_real_contains (GeeAbstractCollection* base, GeeMapEntry* entry) {
2724         GeeHashMapEntrySet * self;
2725         gboolean result = FALSE;
2726         GeeHashMap* _tmp0_;
2727         GeeMapEntry* _tmp1_;
2728         gconstpointer _tmp2_;
2729         gconstpointer _tmp3_;
2730         GeeMapEntry* _tmp4_;
2731         gconstpointer _tmp5_;
2732         gconstpointer _tmp6_;
2733         gboolean _tmp7_ = FALSE;
2734         self = (GeeHashMapEntrySet*) base;
2735         g_return_val_if_fail (entry != NULL, FALSE);
2736         _tmp0_ = self->priv->_map;
2737         _tmp1_ = entry;
2738         _tmp2_ = gee_map_entry_get_key (_tmp1_);
2739         _tmp3_ = _tmp2_;
2740         _tmp4_ = entry;
2741         _tmp5_ = gee_map_entry_get_value (_tmp4_);
2742         _tmp6_ = _tmp5_;
2743         _tmp7_ = gee_abstract_map_has ((GeeAbstractMap*) _tmp0_, _tmp3_, _tmp6_);
2744         result = _tmp7_;
2745         return result;
2746 }
2747
2748
2749 static gboolean gee_hash_map_entry_set_add_all (GeeHashMapEntrySet* self, GeeCollection* entries) {
2750         gboolean result = FALSE;
2751         g_return_val_if_fail (self != NULL, FALSE);
2752         g_return_val_if_fail (entries != NULL, FALSE);
2753         g_assert_not_reached ();
2754         return result;
2755 }
2756
2757
2758 static gboolean gee_hash_map_entry_set_remove_all (GeeHashMapEntrySet* self, GeeCollection* entries) {
2759         gboolean result = FALSE;
2760         g_return_val_if_fail (self != NULL, FALSE);
2761         g_return_val_if_fail (entries != NULL, FALSE);
2762         g_assert_not_reached ();
2763         return result;
2764 }
2765
2766
2767 static gboolean gee_hash_map_entry_set_retain_all (GeeHashMapEntrySet* self, GeeCollection* entries) {
2768         gboolean result = FALSE;
2769         g_return_val_if_fail (self != NULL, FALSE);
2770         g_return_val_if_fail (entries != NULL, FALSE);
2771         g_assert_not_reached ();
2772         return result;
2773 }
2774
2775
2776 static gint gee_hash_map_entry_set_real_get_size (GeeAbstractCollection* base) {
2777         gint result;
2778         GeeHashMapEntrySet* self;
2779         GeeHashMap* _tmp0_;
2780         gint _tmp1_;
2781         gint _tmp2_;
2782         self = (GeeHashMapEntrySet*) base;
2783         _tmp0_ = self->priv->_map;
2784         _tmp1_ = gee_abstract_map_get_size ((GeeMap*) _tmp0_);
2785         _tmp2_ = _tmp1_;
2786         result = _tmp2_;
2787         return result;
2788 }
2789
2790
2791 static gboolean gee_hash_map_entry_set_real_get_read_only (GeeAbstractCollection* base) {
2792         gboolean result;
2793         GeeHashMapEntrySet* self;
2794         self = (GeeHashMapEntrySet*) base;
2795         result = TRUE;
2796         return result;
2797 }
2798
2799
2800 static void gee_hash_map_entry_set_class_init (GeeHashMapEntrySetClass * klass) {
2801         gee_hash_map_entry_set_parent_class = g_type_class_peek_parent (klass);
2802         g_type_class_add_private (klass, sizeof (GeeHashMapEntrySetPrivate));
2803         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_hash_map_entry_set_real_iterator;
2804         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_hash_map_entry_set_real_add;
2805         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_hash_map_entry_set_real_clear;
2806         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_hash_map_entry_set_real_remove;
2807         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_hash_map_entry_set_real_contains;
2808         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_hash_map_entry_set_real_get_size;
2809         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_hash_map_entry_set_real_get_read_only;
2810         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_entry_set_get_property;
2811         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_entry_set_set_property;
2812         G_OBJECT_CLASS (klass)->finalize = gee_hash_map_entry_set_finalize;
2813         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_K_TYPE, g_param_spec_gtype ("k-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));
2814         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_K_DUP_FUNC, g_param_spec_pointer ("k-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));
2815         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
2816         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_V_TYPE, g_param_spec_gtype ("v-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));
2817         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_V_DUP_FUNC, g_param_spec_pointer ("v-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));
2818         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
2819         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2820         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_SET_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2821 }
2822
2823
2824 static void gee_hash_map_entry_set_instance_init (GeeHashMapEntrySet * self) {
2825         self->priv = GEE_HASH_MAP_ENTRY_SET_GET_PRIVATE (self);
2826 }
2827
2828
2829 static void gee_hash_map_entry_set_finalize (GObject* obj) {
2830         GeeHashMapEntrySet * self;
2831         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_HASH_MAP_TYPE_ENTRY_SET, GeeHashMapEntrySet);
2832         _g_object_unref0 (self->priv->_map);
2833         G_OBJECT_CLASS (gee_hash_map_entry_set_parent_class)->finalize (obj);
2834 }
2835
2836
2837 static GType gee_hash_map_entry_set_get_type (void) {
2838         static volatile gsize gee_hash_map_entry_set_type_id__volatile = 0;
2839         if (g_once_init_enter (&gee_hash_map_entry_set_type_id__volatile)) {
2840                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapEntrySetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_entry_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapEntrySet), 0, (GInstanceInitFunc) gee_hash_map_entry_set_instance_init, NULL };
2841                 GType gee_hash_map_entry_set_type_id;
2842                 gee_hash_map_entry_set_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_SET, "GeeHashMapEntrySet", &g_define_type_info, 0);
2843                 g_once_init_leave (&gee_hash_map_entry_set_type_id__volatile, gee_hash_map_entry_set_type_id);
2844         }
2845         return gee_hash_map_entry_set_type_id__volatile;
2846 }
2847
2848
2849 static void _vala_gee_hash_map_entry_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2850         GeeHashMapEntrySet * self;
2851         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_ENTRY_SET, GeeHashMapEntrySet);
2852         switch (property_id) {
2853                 case GEE_HASH_MAP_ENTRY_SET_SIZE:
2854                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
2855                 break;
2856                 case GEE_HASH_MAP_ENTRY_SET_READ_ONLY:
2857                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
2858                 break;
2859                 default:
2860                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2861                 break;
2862         }
2863 }
2864
2865
2866 static void _vala_gee_hash_map_entry_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2867         GeeHashMapEntrySet * self;
2868         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_ENTRY_SET, GeeHashMapEntrySet);
2869         switch (property_id) {
2870                 case GEE_HASH_MAP_ENTRY_SET_K_TYPE:
2871                 self->priv->k_type = g_value_get_gtype (value);
2872                 break;
2873                 case GEE_HASH_MAP_ENTRY_SET_K_DUP_FUNC:
2874                 self->priv->k_dup_func = g_value_get_pointer (value);
2875                 break;
2876                 case GEE_HASH_MAP_ENTRY_SET_K_DESTROY_FUNC:
2877                 self->priv->k_destroy_func = g_value_get_pointer (value);
2878                 break;
2879                 case GEE_HASH_MAP_ENTRY_SET_V_TYPE:
2880                 self->priv->v_type = g_value_get_gtype (value);
2881                 break;
2882                 case GEE_HASH_MAP_ENTRY_SET_V_DUP_FUNC:
2883                 self->priv->v_dup_func = g_value_get_pointer (value);
2884                 break;
2885                 case GEE_HASH_MAP_ENTRY_SET_V_DESTROY_FUNC:
2886                 self->priv->v_destroy_func = g_value_get_pointer (value);
2887                 break;
2888                 default:
2889                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2890                 break;
2891         }
2892 }
2893
2894
2895 static GeeHashMapNodeIterator* gee_hash_map_node_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
2896         GeeHashMapNodeIterator * self = NULL;
2897         GeeHashMap* _tmp0_;
2898         GeeHashMap* _tmp1_;
2899         GeeHashMap* _tmp2_;
2900         gint _tmp3_;
2901         g_return_val_if_fail (map != NULL, NULL);
2902         self = (GeeHashMapNodeIterator*) g_object_new (object_type, NULL);
2903         self->priv->k_type = k_type;
2904         self->priv->k_dup_func = k_dup_func;
2905         self->priv->k_destroy_func = k_destroy_func;
2906         self->priv->v_type = v_type;
2907         self->priv->v_dup_func = v_dup_func;
2908         self->priv->v_destroy_func = v_destroy_func;
2909         _tmp0_ = map;
2910         _tmp1_ = _g_object_ref0 (_tmp0_);
2911         _g_object_unref0 (self->_map);
2912         self->_map = _tmp1_;
2913         _tmp2_ = self->_map;
2914         _tmp3_ = _tmp2_->priv->_stamp;
2915         self->_stamp = _tmp3_;
2916         return self;
2917 }
2918
2919
2920 static gboolean gee_hash_map_node_iterator_next (GeeHashMapNodeIterator* self) {
2921         gboolean result = FALSE;
2922         gint _tmp0_;
2923         GeeHashMap* _tmp1_;
2924         gint _tmp2_;
2925         gboolean _tmp3_ = FALSE;
2926         GeeHashMapNode* _tmp4_;
2927         GeeHashMapNode* _tmp5_;
2928         g_return_val_if_fail (self != NULL, FALSE);
2929         _tmp0_ = self->_stamp;
2930         _tmp1_ = self->_map;
2931         _tmp2_ = _tmp1_->priv->_stamp;
2932         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
2933         _tmp3_ = gee_hash_map_node_iterator_has_next (self);
2934         if (!_tmp3_) {
2935                 result = FALSE;
2936                 return result;
2937         }
2938         _tmp4_ = self->_next;
2939         self->_node = _tmp4_;
2940         self->_next = NULL;
2941         _tmp5_ = self->_node;
2942         result = _tmp5_ != NULL;
2943         return result;
2944 }
2945
2946
2947 static gboolean gee_hash_map_node_iterator_has_next (GeeHashMapNodeIterator* self) {
2948         gboolean result = FALSE;
2949         gint _tmp0_;
2950         GeeHashMap* _tmp1_;
2951         gint _tmp2_;
2952         GeeHashMapNode* _tmp3_;
2953         GeeHashMapNode* _tmp19_;
2954         g_return_val_if_fail (self != NULL, FALSE);
2955         _tmp0_ = self->_stamp;
2956         _tmp1_ = self->_map;
2957         _tmp2_ = _tmp1_->priv->_stamp;
2958         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
2959         _tmp3_ = self->_next;
2960         if (_tmp3_ == NULL) {
2961                 GeeHashMapNode* _tmp4_;
2962                 GeeHashMapNode* _tmp5_;
2963                 _tmp4_ = self->_node;
2964                 self->_next = _tmp4_;
2965                 _tmp5_ = self->_next;
2966                 if (_tmp5_ != NULL) {
2967                         GeeHashMapNode* _tmp6_;
2968                         GeeHashMapNode* _tmp7_;
2969                         _tmp6_ = self->_next;
2970                         _tmp7_ = _tmp6_->next;
2971                         self->_next = _tmp7_;
2972                 }
2973                 while (TRUE) {
2974                         gboolean _tmp8_ = FALSE;
2975                         GeeHashMapNode* _tmp9_;
2976                         gboolean _tmp13_;
2977                         gint _tmp14_;
2978                         GeeHashMap* _tmp15_;
2979                         GeeHashMapNode** _tmp16_;
2980                         gint _tmp16__length1;
2981                         gint _tmp17_;
2982                         GeeHashMapNode* _tmp18_;
2983                         _tmp9_ = self->_next;
2984                         if (_tmp9_ == NULL) {
2985                                 gint _tmp10_;
2986                                 GeeHashMap* _tmp11_;
2987                                 gint _tmp12_;
2988                                 _tmp10_ = self->_index;
2989                                 _tmp11_ = self->_map;
2990                                 _tmp12_ = _tmp11_->priv->_array_size;
2991                                 _tmp8_ = (_tmp10_ + 1) < _tmp12_;
2992                         } else {
2993                                 _tmp8_ = FALSE;
2994                         }
2995                         _tmp13_ = _tmp8_;
2996                         if (!_tmp13_) {
2997                                 break;
2998                         }
2999                         _tmp14_ = self->_index;
3000                         self->_index = _tmp14_ + 1;
3001                         _tmp15_ = self->_map;
3002                         _tmp16_ = _tmp15_->priv->_nodes;
3003                         _tmp16__length1 = _tmp15_->priv->_nodes_length1;
3004                         _tmp17_ = self->_index;
3005                         _tmp18_ = _tmp16_[_tmp17_];
3006                         self->_next = _tmp18_;
3007                 }
3008         }
3009         _tmp19_ = self->_next;
3010         result = _tmp19_ != NULL;
3011         return result;
3012 }
3013
3014
3015 static gboolean gee_hash_map_node_iterator_get_read_only (GeeHashMapNodeIterator* self) {
3016         g_return_val_if_fail (self != NULL, FALSE);
3017         return GEE_HASH_MAP_NODE_ITERATOR_GET_CLASS (self)->get_read_only (self);
3018 }
3019
3020
3021 static gboolean gee_hash_map_node_iterator_real_get_read_only (GeeHashMapNodeIterator* base) {
3022         gboolean result;
3023         GeeHashMapNodeIterator* self;
3024         self = base;
3025         result = TRUE;
3026         return result;
3027 }
3028
3029
3030 static gboolean gee_hash_map_node_iterator_get_valid (GeeHashMapNodeIterator* self) {
3031         gboolean result;
3032         GeeHashMapNode* _tmp0_;
3033         g_return_val_if_fail (self != NULL, FALSE);
3034         _tmp0_ = self->_node;
3035         result = _tmp0_ != NULL;
3036         return result;
3037 }
3038
3039
3040 static void gee_hash_map_node_iterator_class_init (GeeHashMapNodeIteratorClass * klass) {
3041         gee_hash_map_node_iterator_parent_class = g_type_class_peek_parent (klass);
3042         g_type_class_add_private (klass, sizeof (GeeHashMapNodeIteratorPrivate));
3043         GEE_HASH_MAP_NODE_ITERATOR_CLASS (klass)->get_read_only = gee_hash_map_node_iterator_real_get_read_only;
3044         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_node_iterator_get_property;
3045         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_node_iterator_set_property;
3046         G_OBJECT_CLASS (klass)->finalize = gee_hash_map_node_iterator_finalize;
3047         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_ITERATOR_K_TYPE, g_param_spec_gtype ("k-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));
3048         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-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));
3049         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
3050         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_ITERATOR_V_TYPE, g_param_spec_gtype ("v-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));
3051         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-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));
3052         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
3053         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_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));
3054         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_NODE_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));
3055 }
3056
3057
3058 static void gee_hash_map_node_iterator_instance_init (GeeHashMapNodeIterator * self) {
3059         self->priv = GEE_HASH_MAP_NODE_ITERATOR_GET_PRIVATE (self);
3060         self->_index = -1;
3061 }
3062
3063
3064 static void gee_hash_map_node_iterator_finalize (GObject* obj) {
3065         GeeHashMapNodeIterator * self;
3066         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_HASH_MAP_TYPE_NODE_ITERATOR, GeeHashMapNodeIterator);
3067         _g_object_unref0 (self->_map);
3068         G_OBJECT_CLASS (gee_hash_map_node_iterator_parent_class)->finalize (obj);
3069 }
3070
3071
3072 static GType gee_hash_map_node_iterator_get_type (void) {
3073         static volatile gsize gee_hash_map_node_iterator_type_id__volatile = 0;
3074         if (g_once_init_enter (&gee_hash_map_node_iterator_type_id__volatile)) {
3075                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapNodeIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_node_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapNodeIterator), 0, (GInstanceInitFunc) gee_hash_map_node_iterator_instance_init, NULL };
3076                 GType gee_hash_map_node_iterator_type_id;
3077                 gee_hash_map_node_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeHashMapNodeIterator", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
3078                 g_once_init_leave (&gee_hash_map_node_iterator_type_id__volatile, gee_hash_map_node_iterator_type_id);
3079         }
3080         return gee_hash_map_node_iterator_type_id__volatile;
3081 }
3082
3083
3084 static void _vala_gee_hash_map_node_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
3085         GeeHashMapNodeIterator * self;
3086         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_NODE_ITERATOR, GeeHashMapNodeIterator);
3087         switch (property_id) {
3088                 case GEE_HASH_MAP_NODE_ITERATOR_READ_ONLY:
3089                 g_value_set_boolean (value, gee_hash_map_node_iterator_get_read_only (self));
3090                 break;
3091                 case GEE_HASH_MAP_NODE_ITERATOR_VALID:
3092                 g_value_set_boolean (value, gee_hash_map_node_iterator_get_valid (self));
3093                 break;
3094                 default:
3095                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3096                 break;
3097         }
3098 }
3099
3100
3101 static void _vala_gee_hash_map_node_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3102         GeeHashMapNodeIterator * self;
3103         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_NODE_ITERATOR, GeeHashMapNodeIterator);
3104         switch (property_id) {
3105                 case GEE_HASH_MAP_NODE_ITERATOR_K_TYPE:
3106                 self->priv->k_type = g_value_get_gtype (value);
3107                 break;
3108                 case GEE_HASH_MAP_NODE_ITERATOR_K_DUP_FUNC:
3109                 self->priv->k_dup_func = g_value_get_pointer (value);
3110                 break;
3111                 case GEE_HASH_MAP_NODE_ITERATOR_K_DESTROY_FUNC:
3112                 self->priv->k_destroy_func = g_value_get_pointer (value);
3113                 break;
3114                 case GEE_HASH_MAP_NODE_ITERATOR_V_TYPE:
3115                 self->priv->v_type = g_value_get_gtype (value);
3116                 break;
3117                 case GEE_HASH_MAP_NODE_ITERATOR_V_DUP_FUNC:
3118                 self->priv->v_dup_func = g_value_get_pointer (value);
3119                 break;
3120                 case GEE_HASH_MAP_NODE_ITERATOR_V_DESTROY_FUNC:
3121                 self->priv->v_destroy_func = g_value_get_pointer (value);
3122                 break;
3123                 default:
3124                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3125                 break;
3126         }
3127 }
3128
3129
3130 static GeeHashMapKeyIterator* gee_hash_map_key_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3131         GeeHashMapKeyIterator * self = NULL;
3132         GeeHashMap* _tmp0_;
3133         g_return_val_if_fail (map != NULL, NULL);
3134         _tmp0_ = map;
3135         self = (GeeHashMapKeyIterator*) gee_hash_map_node_iterator_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp0_);
3136         self->priv->k_type = k_type;
3137         self->priv->k_dup_func = k_dup_func;
3138         self->priv->k_destroy_func = k_destroy_func;
3139         self->priv->v_type = v_type;
3140         self->priv->v_dup_func = v_dup_func;
3141         self->priv->v_destroy_func = v_destroy_func;
3142         return self;
3143 }
3144
3145
3146 static GeeHashMapKeyIterator* gee_hash_map_key_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3147         return gee_hash_map_key_iterator_construct (GEE_HASH_MAP_TYPE_KEY_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
3148 }
3149
3150
3151 static gpointer gee_hash_map_key_iterator_real_get (GeeIterator* base) {
3152         GeeHashMapKeyIterator * self;
3153         gpointer result = NULL;
3154         gint _tmp0_;
3155         GeeHashMap* _tmp1_;
3156         gint _tmp2_;
3157         GeeHashMapNode* _tmp3_;
3158         GeeHashMapNode* _tmp4_;
3159         gconstpointer _tmp5_;
3160         gpointer _tmp6_;
3161         self = (GeeHashMapKeyIterator*) base;
3162         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_stamp;
3163         _tmp1_ = ((GeeHashMapNodeIterator*) self)->_map;
3164         _tmp2_ = _tmp1_->priv->_stamp;
3165         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
3166         _tmp3_ = ((GeeHashMapNodeIterator*) self)->_node;
3167         _vala_assert (_tmp3_ != NULL, "_node != null");
3168         _tmp4_ = ((GeeHashMapNodeIterator*) self)->_node;
3169         _tmp5_ = _tmp4_->key;
3170         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
3171         result = _tmp6_;
3172         return result;
3173 }
3174
3175
3176 static void gee_hash_map_key_iterator_real_remove (GeeIterator* base) {
3177         GeeHashMapKeyIterator * self;
3178         self = (GeeHashMapKeyIterator*) base;
3179         g_assert_not_reached ();
3180 }
3181
3182
3183 static gboolean gee_hash_map_key_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
3184         GeeHashMapKeyIterator * self;
3185         gboolean result = FALSE;
3186         GeeHashMapNode* _tmp0_;
3187         self = (GeeHashMapKeyIterator*) base;
3188         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_node;
3189         if (_tmp0_ != NULL) {
3190                 GeeForallFunc _tmp1_;
3191                 void* _tmp1__target;
3192                 GeeHashMapNode* _tmp2_;
3193                 gconstpointer _tmp3_;
3194                 gpointer _tmp4_;
3195                 gboolean _tmp5_ = FALSE;
3196                 GeeHashMapNode* _tmp6_;
3197                 _tmp1_ = f;
3198                 _tmp1__target = f_target;
3199                 _tmp2_ = ((GeeHashMapNodeIterator*) self)->_node;
3200                 _tmp3_ = _tmp2_->key;
3201                 _tmp4_ = ((_tmp3_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp3_) : ((gpointer) _tmp3_);
3202                 _tmp5_ = _tmp1_ (_tmp4_, _tmp1__target);
3203                 if (!_tmp5_) {
3204                         result = FALSE;
3205                         return result;
3206                 }
3207                 _tmp6_ = ((GeeHashMapNodeIterator*) self)->_next;
3208                 if (_tmp6_ == NULL) {
3209                         GeeHashMapNode* _tmp7_;
3210                         GeeHashMapNode* _tmp8_;
3211                         _tmp7_ = ((GeeHashMapNodeIterator*) self)->_node;
3212                         _tmp8_ = _tmp7_->next;
3213                         ((GeeHashMapNodeIterator*) self)->_next = _tmp8_;
3214                 }
3215         }
3216         while (TRUE) {
3217                 gint _tmp18_;
3218                 GeeHashMap* _tmp19_;
3219                 gint _tmp20_;
3220                 while (TRUE) {
3221                         GeeHashMapNode* _tmp9_;
3222                         GeeHashMapNode* _tmp10_;
3223                         GeeForallFunc _tmp11_;
3224                         void* _tmp11__target;
3225                         GeeHashMapNode* _tmp12_;
3226                         gconstpointer _tmp13_;
3227                         gpointer _tmp14_;
3228                         gboolean _tmp15_ = FALSE;
3229                         GeeHashMapNode* _tmp16_;
3230                         GeeHashMapNode* _tmp17_;
3231                         _tmp9_ = ((GeeHashMapNodeIterator*) self)->_next;
3232                         if (!(_tmp9_ != NULL)) {
3233                                 break;
3234                         }
3235                         _tmp10_ = ((GeeHashMapNodeIterator*) self)->_next;
3236                         ((GeeHashMapNodeIterator*) self)->_node = _tmp10_;
3237                         _tmp11_ = f;
3238                         _tmp11__target = f_target;
3239                         _tmp12_ = ((GeeHashMapNodeIterator*) self)->_node;
3240                         _tmp13_ = _tmp12_->key;
3241                         _tmp14_ = ((_tmp13_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp13_) : ((gpointer) _tmp13_);
3242                         _tmp15_ = _tmp11_ (_tmp14_, _tmp11__target);
3243                         if (!_tmp15_) {
3244                                 result = FALSE;
3245                                 return result;
3246                         }
3247                         _tmp16_ = ((GeeHashMapNodeIterator*) self)->_next;
3248                         _tmp17_ = _tmp16_->next;
3249                         ((GeeHashMapNodeIterator*) self)->_next = _tmp17_;
3250                 }
3251                 _tmp18_ = ((GeeHashMapNodeIterator*) self)->_index;
3252                 _tmp19_ = ((GeeHashMapNodeIterator*) self)->_map;
3253                 _tmp20_ = _tmp19_->priv->_array_size;
3254                 if ((_tmp18_ + 1) < _tmp20_) {
3255                         GeeHashMap* _tmp21_;
3256                         GeeHashMapNode** _tmp22_;
3257                         gint _tmp22__length1;
3258                         gint _tmp23_;
3259                         gint _tmp24_;
3260                         GeeHashMapNode* _tmp25_;
3261                         _tmp21_ = ((GeeHashMapNodeIterator*) self)->_map;
3262                         _tmp22_ = _tmp21_->priv->_nodes;
3263                         _tmp22__length1 = _tmp21_->priv->_nodes_length1;
3264                         _tmp23_ = ((GeeHashMapNodeIterator*) self)->_index;
3265                         ((GeeHashMapNodeIterator*) self)->_index = _tmp23_ + 1;
3266                         _tmp24_ = ((GeeHashMapNodeIterator*) self)->_index;
3267                         _tmp25_ = _tmp22_[_tmp24_];
3268                         ((GeeHashMapNodeIterator*) self)->_next = _tmp25_;
3269                 } else {
3270                         result = TRUE;
3271                         return result;
3272                 }
3273         }
3274 }
3275
3276
3277 static void gee_hash_map_key_iterator_class_init (GeeHashMapKeyIteratorClass * klass) {
3278         gee_hash_map_key_iterator_parent_class = g_type_class_peek_parent (klass);
3279         g_type_class_add_private (klass, sizeof (GeeHashMapKeyIteratorPrivate));
3280         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_key_iterator_get_property;
3281         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_key_iterator_set_property;
3282         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_ITERATOR_K_TYPE, g_param_spec_gtype ("k-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));
3283         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-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));
3284         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
3285         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_ITERATOR_V_TYPE, g_param_spec_gtype ("v-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));
3286         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-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));
3287         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEY_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
3288 }
3289
3290
3291 static GType gee_hash_map_key_iterator_gee_traversable_get_g_type (GeeHashMapKeyIterator* self) {
3292         return self->priv->k_type;
3293 }
3294
3295
3296 static GBoxedCopyFunc gee_hash_map_key_iterator_gee_traversable_get_g_dup_func (GeeHashMapKeyIterator* self) {
3297         return self->priv->k_dup_func;
3298 }
3299
3300
3301 static GDestroyNotify gee_hash_map_key_iterator_gee_traversable_get_g_destroy_func (GeeHashMapKeyIterator* self) {
3302         return self->priv->k_destroy_func;
3303 }
3304
3305
3306 static void gee_hash_map_key_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
3307         gee_hash_map_key_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
3308         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_hash_map_key_iterator_real_foreach;
3309         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_hash_map_key_iterator_gee_traversable_get_g_type;
3310         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_hash_map_key_iterator_gee_traversable_get_g_dup_func;
3311         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_hash_map_key_iterator_gee_traversable_get_g_destroy_func;
3312 }
3313
3314
3315 static void gee_hash_map_key_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
3316         gee_hash_map_key_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
3317         iface->get = (gpointer (*)(GeeIterator*)) gee_hash_map_key_iterator_real_get;
3318         iface->remove = (void (*)(GeeIterator*)) gee_hash_map_key_iterator_real_remove;
3319         iface->next = (gboolean (*)(GeeIterator*)) gee_hash_map_node_iterator_next;
3320         iface->has_next = (gboolean (*)(GeeIterator*)) gee_hash_map_node_iterator_has_next;
3321         iface->get_valid = (gboolean (*) (GeeIterator *)) gee_hash_map_node_iterator_get_valid;
3322         iface->get_read_only = (gboolean (*) (GeeIterator *)) gee_hash_map_node_iterator_get_read_only;
3323 }
3324
3325
3326 static void gee_hash_map_key_iterator_instance_init (GeeHashMapKeyIterator * self) {
3327         self->priv = GEE_HASH_MAP_KEY_ITERATOR_GET_PRIVATE (self);
3328 }
3329
3330
3331 static GType gee_hash_map_key_iterator_get_type (void) {
3332         static volatile gsize gee_hash_map_key_iterator_type_id__volatile = 0;
3333         if (g_once_init_enter (&gee_hash_map_key_iterator_type_id__volatile)) {
3334                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapKeyIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_key_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapKeyIterator), 0, (GInstanceInitFunc) gee_hash_map_key_iterator_instance_init, NULL };
3335                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_hash_map_key_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3336                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_hash_map_key_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3337                 GType gee_hash_map_key_iterator_type_id;
3338                 gee_hash_map_key_iterator_type_id = g_type_register_static (GEE_HASH_MAP_TYPE_NODE_ITERATOR, "GeeHashMapKeyIterator", &g_define_type_info, 0);
3339                 g_type_add_interface_static (gee_hash_map_key_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
3340                 g_type_add_interface_static (gee_hash_map_key_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
3341                 g_once_init_leave (&gee_hash_map_key_iterator_type_id__volatile, gee_hash_map_key_iterator_type_id);
3342         }
3343         return gee_hash_map_key_iterator_type_id__volatile;
3344 }
3345
3346
3347 static void _vala_gee_hash_map_key_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
3348         GeeHashMapKeyIterator * self;
3349         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_KEY_ITERATOR, GeeHashMapKeyIterator);
3350         switch (property_id) {
3351                 default:
3352                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3353                 break;
3354         }
3355 }
3356
3357
3358 static void _vala_gee_hash_map_key_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3359         GeeHashMapKeyIterator * self;
3360         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_KEY_ITERATOR, GeeHashMapKeyIterator);
3361         switch (property_id) {
3362                 case GEE_HASH_MAP_KEY_ITERATOR_K_TYPE:
3363                 self->priv->k_type = g_value_get_gtype (value);
3364                 break;
3365                 case GEE_HASH_MAP_KEY_ITERATOR_K_DUP_FUNC:
3366                 self->priv->k_dup_func = g_value_get_pointer (value);
3367                 break;
3368                 case GEE_HASH_MAP_KEY_ITERATOR_K_DESTROY_FUNC:
3369                 self->priv->k_destroy_func = g_value_get_pointer (value);
3370                 break;
3371                 case GEE_HASH_MAP_KEY_ITERATOR_V_TYPE:
3372                 self->priv->v_type = g_value_get_gtype (value);
3373                 break;
3374                 case GEE_HASH_MAP_KEY_ITERATOR_V_DUP_FUNC:
3375                 self->priv->v_dup_func = g_value_get_pointer (value);
3376                 break;
3377                 case GEE_HASH_MAP_KEY_ITERATOR_V_DESTROY_FUNC:
3378                 self->priv->v_destroy_func = g_value_get_pointer (value);
3379                 break;
3380                 default:
3381                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3382                 break;
3383         }
3384 }
3385
3386
3387 static GeeHashMapMapIterator* gee_hash_map_map_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3388         GeeHashMapMapIterator * self = NULL;
3389         GeeHashMap* _tmp0_;
3390         g_return_val_if_fail (map != NULL, NULL);
3391         _tmp0_ = map;
3392         self = (GeeHashMapMapIterator*) gee_hash_map_node_iterator_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp0_);
3393         self->priv->k_type = k_type;
3394         self->priv->k_dup_func = k_dup_func;
3395         self->priv->k_destroy_func = k_destroy_func;
3396         self->priv->v_type = v_type;
3397         self->priv->v_dup_func = v_dup_func;
3398         self->priv->v_destroy_func = v_destroy_func;
3399         return self;
3400 }
3401
3402
3403 static GeeHashMapMapIterator* gee_hash_map_map_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3404         return gee_hash_map_map_iterator_construct (GEE_HASH_MAP_TYPE_MAP_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
3405 }
3406
3407
3408 static gpointer gee_hash_map_map_iterator_real_get_key (GeeMapIterator* base) {
3409         GeeHashMapMapIterator * self;
3410         gpointer result = NULL;
3411         gint _tmp0_;
3412         GeeHashMap* _tmp1_;
3413         gint _tmp2_;
3414         GeeHashMapNode* _tmp3_;
3415         GeeHashMapNode* _tmp4_;
3416         gconstpointer _tmp5_;
3417         gpointer _tmp6_;
3418         self = (GeeHashMapMapIterator*) base;
3419         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_stamp;
3420         _tmp1_ = ((GeeHashMapNodeIterator*) self)->_map;
3421         _tmp2_ = _tmp1_->priv->_stamp;
3422         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
3423         _tmp3_ = ((GeeHashMapNodeIterator*) self)->_node;
3424         _vala_assert (_tmp3_ != NULL, "_node != null");
3425         _tmp4_ = ((GeeHashMapNodeIterator*) self)->_node;
3426         _tmp5_ = _tmp4_->key;
3427         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
3428         result = _tmp6_;
3429         return result;
3430 }
3431
3432
3433 static void gee_hash_map_map_iterator_real_unset (GeeMapIterator* base) {
3434         GeeHashMapMapIterator * self;
3435         gint _tmp0_;
3436         GeeHashMap* _tmp1_;
3437         gint _tmp2_;
3438         GeeHashMapNode* _tmp3_;
3439         GeeHashMap* _tmp4_;
3440         GeeHashMapNode* _tmp5_;
3441         gconstpointer _tmp6_;
3442         GeeHashMap* _tmp7_;
3443         gint _tmp8_;
3444         self = (GeeHashMapMapIterator*) base;
3445         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_stamp;
3446         _tmp1_ = ((GeeHashMapNodeIterator*) self)->_map;
3447         _tmp2_ = _tmp1_->priv->_stamp;
3448         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
3449         _tmp3_ = ((GeeHashMapNodeIterator*) self)->_node;
3450         _vala_assert (_tmp3_ != NULL, "_node != null");
3451         gee_map_iterator_has_next ((GeeMapIterator*) self);
3452         _tmp4_ = ((GeeHashMapNodeIterator*) self)->_map;
3453         _tmp5_ = ((GeeHashMapNodeIterator*) self)->_node;
3454         _tmp6_ = _tmp5_->key;
3455         gee_hash_map_unset_helper (_tmp4_, _tmp6_, NULL);
3456         ((GeeHashMapNodeIterator*) self)->_node = NULL;
3457         _tmp7_ = ((GeeHashMapNodeIterator*) self)->_map;
3458         _tmp8_ = _tmp7_->priv->_stamp;
3459         ((GeeHashMapNodeIterator*) self)->_stamp = _tmp8_;
3460 }
3461
3462
3463 static gpointer gee_hash_map_map_iterator_real_get_value (GeeMapIterator* base) {
3464         GeeHashMapMapIterator * self;
3465         gpointer result = NULL;
3466         gint _tmp0_;
3467         GeeHashMap* _tmp1_;
3468         gint _tmp2_;
3469         GeeHashMapNode* _tmp3_;
3470         GeeHashMapNode* _tmp4_;
3471         gconstpointer _tmp5_;
3472         gpointer _tmp6_;
3473         self = (GeeHashMapMapIterator*) base;
3474         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_stamp;
3475         _tmp1_ = ((GeeHashMapNodeIterator*) self)->_map;
3476         _tmp2_ = _tmp1_->priv->_stamp;
3477         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
3478         _tmp3_ = ((GeeHashMapNodeIterator*) self)->_node;
3479         _vala_assert (_tmp3_ != NULL, "_node != null");
3480         _tmp4_ = ((GeeHashMapNodeIterator*) self)->_node;
3481         _tmp5_ = _tmp4_->value;
3482         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
3483         result = _tmp6_;
3484         return result;
3485 }
3486
3487
3488 static void gee_hash_map_map_iterator_real_set_value (GeeMapIterator* base, gconstpointer value) {
3489         GeeHashMapMapIterator * self;
3490         gint _tmp0_;
3491         GeeHashMap* _tmp1_;
3492         gint _tmp2_;
3493         GeeHashMapNode* _tmp3_;
3494         GeeHashMap* _tmp4_;
3495         GeeHashMapNode* _tmp5_;
3496         gconstpointer _tmp6_;
3497         gconstpointer _tmp7_;
3498         GeeHashMap* _tmp8_;
3499         gint _tmp9_;
3500         self = (GeeHashMapMapIterator*) base;
3501         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_stamp;
3502         _tmp1_ = ((GeeHashMapNodeIterator*) self)->_map;
3503         _tmp2_ = _tmp1_->priv->_stamp;
3504         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
3505         _tmp3_ = ((GeeHashMapNodeIterator*) self)->_node;
3506         _vala_assert (_tmp3_ != NULL, "_node != null");
3507         _tmp4_ = ((GeeHashMapNodeIterator*) self)->_map;
3508         _tmp5_ = ((GeeHashMapNodeIterator*) self)->_node;
3509         _tmp6_ = _tmp5_->key;
3510         _tmp7_ = value;
3511         gee_abstract_map_set ((GeeAbstractMap*) _tmp4_, _tmp6_, _tmp7_);
3512         _tmp8_ = ((GeeHashMapNodeIterator*) self)->_map;
3513         _tmp9_ = _tmp8_->priv->_stamp;
3514         ((GeeHashMapNodeIterator*) self)->_stamp = _tmp9_;
3515 }
3516
3517
3518 static gboolean gee_hash_map_map_iterator_real_get_mutable (GeeMapIterator* base) {
3519         gboolean result;
3520         GeeHashMapMapIterator* self;
3521         self = (GeeHashMapMapIterator*) base;
3522         result = TRUE;
3523         return result;
3524 }
3525
3526
3527 static gboolean gee_hash_map_map_iterator_real_get_read_only (GeeHashMapNodeIterator* base) {
3528         gboolean result;
3529         GeeHashMapMapIterator* self;
3530         self = (GeeHashMapMapIterator*) base;
3531         result = FALSE;
3532         return result;
3533 }
3534
3535
3536 static void gee_hash_map_map_iterator_class_init (GeeHashMapMapIteratorClass * klass) {
3537         gee_hash_map_map_iterator_parent_class = g_type_class_peek_parent (klass);
3538         g_type_class_add_private (klass, sizeof (GeeHashMapMapIteratorPrivate));
3539         GEE_HASH_MAP_NODE_ITERATOR_CLASS (klass)->get_read_only = gee_hash_map_map_iterator_real_get_read_only;
3540         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_map_iterator_get_property;
3541         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_map_iterator_set_property;
3542         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_ITERATOR_K_TYPE, g_param_spec_gtype ("k-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));
3543         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-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));
3544         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
3545         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_ITERATOR_V_TYPE, g_param_spec_gtype ("v-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));
3546         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-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));
3547         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
3548         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_ITERATOR_MUTABLE, g_param_spec_boolean ("mutable", "mutable", "mutable", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
3549         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_MAP_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));
3550 }
3551
3552
3553 static GType gee_hash_map_map_iterator_gee_map_iterator_get_k_type (GeeHashMapMapIterator* self) {
3554         return self->priv->k_type;
3555 }
3556
3557
3558 static GBoxedCopyFunc gee_hash_map_map_iterator_gee_map_iterator_get_k_dup_func (GeeHashMapMapIterator* self) {
3559         return self->priv->k_dup_func;
3560 }
3561
3562
3563 static GDestroyNotify gee_hash_map_map_iterator_gee_map_iterator_get_k_destroy_func (GeeHashMapMapIterator* self) {
3564         return self->priv->k_destroy_func;
3565 }
3566
3567
3568 static GType gee_hash_map_map_iterator_gee_map_iterator_get_v_type (GeeHashMapMapIterator* self) {
3569         return self->priv->v_type;
3570 }
3571
3572
3573 static GBoxedCopyFunc gee_hash_map_map_iterator_gee_map_iterator_get_v_dup_func (GeeHashMapMapIterator* self) {
3574         return self->priv->v_dup_func;
3575 }
3576
3577
3578 static GDestroyNotify gee_hash_map_map_iterator_gee_map_iterator_get_v_destroy_func (GeeHashMapMapIterator* self) {
3579         return self->priv->v_destroy_func;
3580 }
3581
3582
3583 static void gee_hash_map_map_iterator_gee_map_iterator_interface_init (GeeMapIteratorIface * iface) {
3584         gee_hash_map_map_iterator_gee_map_iterator_parent_iface = g_type_interface_peek_parent (iface);
3585         iface->get_key = (gpointer (*)(GeeMapIterator*)) gee_hash_map_map_iterator_real_get_key;
3586         iface->unset = (void (*)(GeeMapIterator*)) gee_hash_map_map_iterator_real_unset;
3587         iface->get_value = (gpointer (*)(GeeMapIterator*)) gee_hash_map_map_iterator_real_get_value;
3588         iface->set_value = (void (*)(GeeMapIterator*, gconstpointer)) gee_hash_map_map_iterator_real_set_value;
3589         iface->get_k_type = (GType(*)(GeeMapIterator*)) gee_hash_map_map_iterator_gee_map_iterator_get_k_type;
3590         iface->get_k_dup_func = (GBoxedCopyFunc(*)(GeeMapIterator*)) gee_hash_map_map_iterator_gee_map_iterator_get_k_dup_func;
3591         iface->get_k_destroy_func = (GDestroyNotify(*)(GeeMapIterator*)) gee_hash_map_map_iterator_gee_map_iterator_get_k_destroy_func;
3592         iface->get_v_type = (GType(*)(GeeMapIterator*)) gee_hash_map_map_iterator_gee_map_iterator_get_v_type;
3593         iface->get_v_dup_func = (GBoxedCopyFunc(*)(GeeMapIterator*)) gee_hash_map_map_iterator_gee_map_iterator_get_v_dup_func;
3594         iface->get_v_destroy_func = (GDestroyNotify(*)(GeeMapIterator*)) gee_hash_map_map_iterator_gee_map_iterator_get_v_destroy_func;
3595         iface->next = (gboolean (*)(GeeMapIterator*)) gee_hash_map_node_iterator_next;
3596         iface->has_next = (gboolean (*)(GeeMapIterator*)) gee_hash_map_node_iterator_has_next;
3597         iface->get_mutable = gee_hash_map_map_iterator_real_get_mutable;
3598         iface->get_read_only = gee_hash_map_map_iterator_real_get_read_only;
3599         iface->get_valid = (gboolean (*) (GeeMapIterator *)) gee_hash_map_node_iterator_get_valid;
3600 }
3601
3602
3603 static void gee_hash_map_map_iterator_instance_init (GeeHashMapMapIterator * self) {
3604         self->priv = GEE_HASH_MAP_MAP_ITERATOR_GET_PRIVATE (self);
3605 }
3606
3607
3608 static GType gee_hash_map_map_iterator_get_type (void) {
3609         static volatile gsize gee_hash_map_map_iterator_type_id__volatile = 0;
3610         if (g_once_init_enter (&gee_hash_map_map_iterator_type_id__volatile)) {
3611                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapMapIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_map_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapMapIterator), 0, (GInstanceInitFunc) gee_hash_map_map_iterator_instance_init, NULL };
3612                 static const GInterfaceInfo gee_map_iterator_info = { (GInterfaceInitFunc) gee_hash_map_map_iterator_gee_map_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3613                 GType gee_hash_map_map_iterator_type_id;
3614                 gee_hash_map_map_iterator_type_id = g_type_register_static (GEE_HASH_MAP_TYPE_NODE_ITERATOR, "GeeHashMapMapIterator", &g_define_type_info, 0);
3615                 g_type_add_interface_static (gee_hash_map_map_iterator_type_id, GEE_TYPE_MAP_ITERATOR, &gee_map_iterator_info);
3616                 g_once_init_leave (&gee_hash_map_map_iterator_type_id__volatile, gee_hash_map_map_iterator_type_id);
3617         }
3618         return gee_hash_map_map_iterator_type_id__volatile;
3619 }
3620
3621
3622 static void _vala_gee_hash_map_map_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
3623         GeeHashMapMapIterator * self;
3624         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_MAP_ITERATOR, GeeHashMapMapIterator);
3625         switch (property_id) {
3626                 case GEE_HASH_MAP_MAP_ITERATOR_MUTABLE:
3627                 g_value_set_boolean (value, gee_map_iterator_get_mutable ((GeeMapIterator*) self));
3628                 break;
3629                 case GEE_HASH_MAP_MAP_ITERATOR_READ_ONLY:
3630                 g_value_set_boolean (value, gee_hash_map_node_iterator_get_read_only ((GeeHashMapNodeIterator*) self));
3631                 break;
3632                 default:
3633                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3634                 break;
3635         }
3636 }
3637
3638
3639 static void _vala_gee_hash_map_map_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3640         GeeHashMapMapIterator * self;
3641         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_MAP_ITERATOR, GeeHashMapMapIterator);
3642         switch (property_id) {
3643                 case GEE_HASH_MAP_MAP_ITERATOR_K_TYPE:
3644                 self->priv->k_type = g_value_get_gtype (value);
3645                 break;
3646                 case GEE_HASH_MAP_MAP_ITERATOR_K_DUP_FUNC:
3647                 self->priv->k_dup_func = g_value_get_pointer (value);
3648                 break;
3649                 case GEE_HASH_MAP_MAP_ITERATOR_K_DESTROY_FUNC:
3650                 self->priv->k_destroy_func = g_value_get_pointer (value);
3651                 break;
3652                 case GEE_HASH_MAP_MAP_ITERATOR_V_TYPE:
3653                 self->priv->v_type = g_value_get_gtype (value);
3654                 break;
3655                 case GEE_HASH_MAP_MAP_ITERATOR_V_DUP_FUNC:
3656                 self->priv->v_dup_func = g_value_get_pointer (value);
3657                 break;
3658                 case GEE_HASH_MAP_MAP_ITERATOR_V_DESTROY_FUNC:
3659                 self->priv->v_destroy_func = g_value_get_pointer (value);
3660                 break;
3661                 default:
3662                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3663                 break;
3664         }
3665 }
3666
3667
3668 static GeeHashMapValueIterator* gee_hash_map_value_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3669         GeeHashMapValueIterator * self = NULL;
3670         GeeHashMap* _tmp0_;
3671         g_return_val_if_fail (map != NULL, NULL);
3672         _tmp0_ = map;
3673         self = (GeeHashMapValueIterator*) gee_hash_map_node_iterator_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp0_);
3674         self->priv->k_type = k_type;
3675         self->priv->k_dup_func = k_dup_func;
3676         self->priv->k_destroy_func = k_destroy_func;
3677         self->priv->v_type = v_type;
3678         self->priv->v_dup_func = v_dup_func;
3679         self->priv->v_destroy_func = v_destroy_func;
3680         return self;
3681 }
3682
3683
3684 static GeeHashMapValueIterator* gee_hash_map_value_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3685         return gee_hash_map_value_iterator_construct (GEE_HASH_MAP_TYPE_VALUE_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
3686 }
3687
3688
3689 static gpointer gee_hash_map_value_iterator_real_get (GeeIterator* base) {
3690         GeeHashMapValueIterator * self;
3691         gpointer result = NULL;
3692         gint _tmp0_;
3693         GeeHashMap* _tmp1_;
3694         gint _tmp2_;
3695         GeeHashMapNode* _tmp3_;
3696         GeeHashMapNode* _tmp4_;
3697         gconstpointer _tmp5_;
3698         gpointer _tmp6_;
3699         self = (GeeHashMapValueIterator*) base;
3700         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_stamp;
3701         _tmp1_ = ((GeeHashMapNodeIterator*) self)->_map;
3702         _tmp2_ = _tmp1_->priv->_stamp;
3703         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
3704         _tmp3_ = ((GeeHashMapNodeIterator*) self)->_node;
3705         _vala_assert (_tmp3_ != NULL, "_node != null");
3706         _tmp4_ = ((GeeHashMapNodeIterator*) self)->_node;
3707         _tmp5_ = _tmp4_->value;
3708         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
3709         result = _tmp6_;
3710         return result;
3711 }
3712
3713
3714 static void gee_hash_map_value_iterator_real_remove (GeeIterator* base) {
3715         GeeHashMapValueIterator * self;
3716         self = (GeeHashMapValueIterator*) base;
3717         g_assert_not_reached ();
3718 }
3719
3720
3721 static gboolean gee_hash_map_value_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
3722         GeeHashMapValueIterator * self;
3723         gboolean result = FALSE;
3724         GeeHashMapNode* _tmp0_;
3725         self = (GeeHashMapValueIterator*) base;
3726         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_node;
3727         if (_tmp0_ != NULL) {
3728                 GeeForallFunc _tmp1_;
3729                 void* _tmp1__target;
3730                 GeeHashMapNode* _tmp2_;
3731                 gconstpointer _tmp3_;
3732                 gpointer _tmp4_;
3733                 gboolean _tmp5_ = FALSE;
3734                 GeeHashMapNode* _tmp6_;
3735                 _tmp1_ = f;
3736                 _tmp1__target = f_target;
3737                 _tmp2_ = ((GeeHashMapNodeIterator*) self)->_node;
3738                 _tmp3_ = _tmp2_->value;
3739                 _tmp4_ = ((_tmp3_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp3_) : ((gpointer) _tmp3_);
3740                 _tmp5_ = _tmp1_ (_tmp4_, _tmp1__target);
3741                 if (!_tmp5_) {
3742                         result = FALSE;
3743                         return result;
3744                 }
3745                 _tmp6_ = ((GeeHashMapNodeIterator*) self)->_next;
3746                 if (_tmp6_ == NULL) {
3747                         GeeHashMapNode* _tmp7_;
3748                         GeeHashMapNode* _tmp8_;
3749                         _tmp7_ = ((GeeHashMapNodeIterator*) self)->_node;
3750                         _tmp8_ = _tmp7_->next;
3751                         ((GeeHashMapNodeIterator*) self)->_next = _tmp8_;
3752                 }
3753         }
3754         while (TRUE) {
3755                 gint _tmp18_;
3756                 GeeHashMap* _tmp19_;
3757                 gint _tmp20_;
3758                 while (TRUE) {
3759                         GeeHashMapNode* _tmp9_;
3760                         GeeHashMapNode* _tmp10_;
3761                         GeeForallFunc _tmp11_;
3762                         void* _tmp11__target;
3763                         GeeHashMapNode* _tmp12_;
3764                         gconstpointer _tmp13_;
3765                         gpointer _tmp14_;
3766                         gboolean _tmp15_ = FALSE;
3767                         GeeHashMapNode* _tmp16_;
3768                         GeeHashMapNode* _tmp17_;
3769                         _tmp9_ = ((GeeHashMapNodeIterator*) self)->_next;
3770                         if (!(_tmp9_ != NULL)) {
3771                                 break;
3772                         }
3773                         _tmp10_ = ((GeeHashMapNodeIterator*) self)->_next;
3774                         ((GeeHashMapNodeIterator*) self)->_node = _tmp10_;
3775                         _tmp11_ = f;
3776                         _tmp11__target = f_target;
3777                         _tmp12_ = ((GeeHashMapNodeIterator*) self)->_node;
3778                         _tmp13_ = _tmp12_->value;
3779                         _tmp14_ = ((_tmp13_ != NULL) && (self->priv->v_dup_func != NULL)) ? self->priv->v_dup_func ((gpointer) _tmp13_) : ((gpointer) _tmp13_);
3780                         _tmp15_ = _tmp11_ (_tmp14_, _tmp11__target);
3781                         if (!_tmp15_) {
3782                                 result = FALSE;
3783                                 return result;
3784                         }
3785                         _tmp16_ = ((GeeHashMapNodeIterator*) self)->_next;
3786                         _tmp17_ = _tmp16_->next;
3787                         ((GeeHashMapNodeIterator*) self)->_next = _tmp17_;
3788                 }
3789                 _tmp18_ = ((GeeHashMapNodeIterator*) self)->_index;
3790                 _tmp19_ = ((GeeHashMapNodeIterator*) self)->_map;
3791                 _tmp20_ = _tmp19_->priv->_array_size;
3792                 if ((_tmp18_ + 1) < _tmp20_) {
3793                         GeeHashMap* _tmp21_;
3794                         GeeHashMapNode** _tmp22_;
3795                         gint _tmp22__length1;
3796                         gint _tmp23_;
3797                         gint _tmp24_;
3798                         GeeHashMapNode* _tmp25_;
3799                         _tmp21_ = ((GeeHashMapNodeIterator*) self)->_map;
3800                         _tmp22_ = _tmp21_->priv->_nodes;
3801                         _tmp22__length1 = _tmp21_->priv->_nodes_length1;
3802                         _tmp23_ = ((GeeHashMapNodeIterator*) self)->_index;
3803                         ((GeeHashMapNodeIterator*) self)->_index = _tmp23_ + 1;
3804                         _tmp24_ = ((GeeHashMapNodeIterator*) self)->_index;
3805                         _tmp25_ = _tmp22_[_tmp24_];
3806                         ((GeeHashMapNodeIterator*) self)->_next = _tmp25_;
3807                 } else {
3808                         result = TRUE;
3809                         return result;
3810                 }
3811         }
3812 }
3813
3814
3815 static void gee_hash_map_value_iterator_class_init (GeeHashMapValueIteratorClass * klass) {
3816         gee_hash_map_value_iterator_parent_class = g_type_class_peek_parent (klass);
3817         g_type_class_add_private (klass, sizeof (GeeHashMapValueIteratorPrivate));
3818         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_value_iterator_get_property;
3819         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_value_iterator_set_property;
3820         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_ITERATOR_K_TYPE, g_param_spec_gtype ("k-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));
3821         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-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));
3822         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
3823         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_ITERATOR_V_TYPE, g_param_spec_gtype ("v-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));
3824         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-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));
3825         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUE_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
3826 }
3827
3828
3829 static GType gee_hash_map_value_iterator_gee_traversable_get_g_type (GeeHashMapValueIterator* self) {
3830         return self->priv->v_type;
3831 }
3832
3833
3834 static GBoxedCopyFunc gee_hash_map_value_iterator_gee_traversable_get_g_dup_func (GeeHashMapValueIterator* self) {
3835         return self->priv->v_dup_func;
3836 }
3837
3838
3839 static GDestroyNotify gee_hash_map_value_iterator_gee_traversable_get_g_destroy_func (GeeHashMapValueIterator* self) {
3840         return self->priv->v_destroy_func;
3841 }
3842
3843
3844 static void gee_hash_map_value_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
3845         gee_hash_map_value_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
3846         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_hash_map_value_iterator_real_foreach;
3847         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_hash_map_value_iterator_gee_traversable_get_g_type;
3848         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_hash_map_value_iterator_gee_traversable_get_g_dup_func;
3849         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_hash_map_value_iterator_gee_traversable_get_g_destroy_func;
3850 }
3851
3852
3853 static void gee_hash_map_value_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
3854         gee_hash_map_value_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
3855         iface->get = (gpointer (*)(GeeIterator*)) gee_hash_map_value_iterator_real_get;
3856         iface->remove = (void (*)(GeeIterator*)) gee_hash_map_value_iterator_real_remove;
3857         iface->next = (gboolean (*)(GeeIterator*)) gee_hash_map_node_iterator_next;
3858         iface->has_next = (gboolean (*)(GeeIterator*)) gee_hash_map_node_iterator_has_next;
3859         iface->get_valid = (gboolean (*) (GeeIterator *)) gee_hash_map_node_iterator_get_valid;
3860         iface->get_read_only = (gboolean (*) (GeeIterator *)) gee_hash_map_node_iterator_get_read_only;
3861 }
3862
3863
3864 static void gee_hash_map_value_iterator_instance_init (GeeHashMapValueIterator * self) {
3865         self->priv = GEE_HASH_MAP_VALUE_ITERATOR_GET_PRIVATE (self);
3866 }
3867
3868
3869 static GType gee_hash_map_value_iterator_get_type (void) {
3870         static volatile gsize gee_hash_map_value_iterator_type_id__volatile = 0;
3871         if (g_once_init_enter (&gee_hash_map_value_iterator_type_id__volatile)) {
3872                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapValueIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_value_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapValueIterator), 0, (GInstanceInitFunc) gee_hash_map_value_iterator_instance_init, NULL };
3873                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_hash_map_value_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3874                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_hash_map_value_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3875                 GType gee_hash_map_value_iterator_type_id;
3876                 gee_hash_map_value_iterator_type_id = g_type_register_static (GEE_HASH_MAP_TYPE_NODE_ITERATOR, "GeeHashMapValueIterator", &g_define_type_info, 0);
3877                 g_type_add_interface_static (gee_hash_map_value_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
3878                 g_type_add_interface_static (gee_hash_map_value_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
3879                 g_once_init_leave (&gee_hash_map_value_iterator_type_id__volatile, gee_hash_map_value_iterator_type_id);
3880         }
3881         return gee_hash_map_value_iterator_type_id__volatile;
3882 }
3883
3884
3885 static void _vala_gee_hash_map_value_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
3886         GeeHashMapValueIterator * self;
3887         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_VALUE_ITERATOR, GeeHashMapValueIterator);
3888         switch (property_id) {
3889                 default:
3890                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3891                 break;
3892         }
3893 }
3894
3895
3896 static void _vala_gee_hash_map_value_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3897         GeeHashMapValueIterator * self;
3898         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_VALUE_ITERATOR, GeeHashMapValueIterator);
3899         switch (property_id) {
3900                 case GEE_HASH_MAP_VALUE_ITERATOR_K_TYPE:
3901                 self->priv->k_type = g_value_get_gtype (value);
3902                 break;
3903                 case GEE_HASH_MAP_VALUE_ITERATOR_K_DUP_FUNC:
3904                 self->priv->k_dup_func = g_value_get_pointer (value);
3905                 break;
3906                 case GEE_HASH_MAP_VALUE_ITERATOR_K_DESTROY_FUNC:
3907                 self->priv->k_destroy_func = g_value_get_pointer (value);
3908                 break;
3909                 case GEE_HASH_MAP_VALUE_ITERATOR_V_TYPE:
3910                 self->priv->v_type = g_value_get_gtype (value);
3911                 break;
3912                 case GEE_HASH_MAP_VALUE_ITERATOR_V_DUP_FUNC:
3913                 self->priv->v_dup_func = g_value_get_pointer (value);
3914                 break;
3915                 case GEE_HASH_MAP_VALUE_ITERATOR_V_DESTROY_FUNC:
3916                 self->priv->v_destroy_func = g_value_get_pointer (value);
3917                 break;
3918                 default:
3919                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3920                 break;
3921         }
3922 }
3923
3924
3925 static GeeHashMapEntryIterator* gee_hash_map_entry_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3926         GeeHashMapEntryIterator * self = NULL;
3927         GeeHashMap* _tmp0_;
3928         g_return_val_if_fail (map != NULL, NULL);
3929         _tmp0_ = map;
3930         self = (GeeHashMapEntryIterator*) gee_hash_map_node_iterator_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp0_);
3931         self->priv->k_type = k_type;
3932         self->priv->k_dup_func = k_dup_func;
3933         self->priv->k_destroy_func = k_destroy_func;
3934         self->priv->v_type = v_type;
3935         self->priv->v_dup_func = v_dup_func;
3936         self->priv->v_destroy_func = v_destroy_func;
3937         return self;
3938 }
3939
3940
3941 static GeeHashMapEntryIterator* gee_hash_map_entry_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashMap* map) {
3942         return gee_hash_map_entry_iterator_construct (GEE_HASH_MAP_TYPE_ENTRY_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
3943 }
3944
3945
3946 static GeeMapEntry* gee_hash_map_entry_iterator_real_get (GeeIterator* base) {
3947         GeeHashMapEntryIterator * self;
3948         GeeMapEntry* result = NULL;
3949         gint _tmp0_;
3950         GeeHashMap* _tmp1_;
3951         gint _tmp2_;
3952         GeeHashMapNode* _tmp3_;
3953         GeeHashMapNode* _tmp4_;
3954         GeeMapEntry* _tmp5_ = NULL;
3955         self = (GeeHashMapEntryIterator*) base;
3956         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_stamp;
3957         _tmp1_ = ((GeeHashMapNodeIterator*) self)->_map;
3958         _tmp2_ = _tmp1_->priv->_stamp;
3959         _vala_assert (_tmp0_ == _tmp2_, "_stamp == _map._stamp");
3960         _tmp3_ = ((GeeHashMapNodeIterator*) self)->_node;
3961         _vala_assert (_tmp3_ != NULL, "_node != null");
3962         _tmp4_ = ((GeeHashMapNodeIterator*) self)->_node;
3963         _tmp5_ = gee_hash_map_entry_entry_for (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp4_);
3964         result = _tmp5_;
3965         return result;
3966 }
3967
3968
3969 static void gee_hash_map_entry_iterator_real_remove (GeeIterator* base) {
3970         GeeHashMapEntryIterator * self;
3971         self = (GeeHashMapEntryIterator*) base;
3972         g_assert_not_reached ();
3973 }
3974
3975
3976 static gboolean gee_hash_map_entry_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
3977         GeeHashMapEntryIterator * self;
3978         gboolean result = FALSE;
3979         GeeHashMapNode* _tmp0_;
3980         self = (GeeHashMapEntryIterator*) base;
3981         _tmp0_ = ((GeeHashMapNodeIterator*) self)->_node;
3982         if (_tmp0_ != NULL) {
3983                 GeeForallFunc _tmp1_;
3984                 void* _tmp1__target;
3985                 GeeHashMapNode* _tmp2_;
3986                 GeeMapEntry* _tmp3_ = NULL;
3987                 gboolean _tmp4_ = FALSE;
3988                 GeeHashMapNode* _tmp5_;
3989                 _tmp1_ = f;
3990                 _tmp1__target = f_target;
3991                 _tmp2_ = ((GeeHashMapNodeIterator*) self)->_node;
3992                 _tmp3_ = gee_hash_map_entry_entry_for (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp2_);
3993                 _tmp4_ = _tmp1_ (_tmp3_, _tmp1__target);
3994                 if (!_tmp4_) {
3995                         result = FALSE;
3996                         return result;
3997                 }
3998                 _tmp5_ = ((GeeHashMapNodeIterator*) self)->_next;
3999                 if (_tmp5_ == NULL) {
4000                         GeeHashMapNode* _tmp6_;
4001                         GeeHashMapNode* _tmp7_;
4002                         _tmp6_ = ((GeeHashMapNodeIterator*) self)->_node;
4003                         _tmp7_ = _tmp6_->next;
4004                         ((GeeHashMapNodeIterator*) self)->_next = _tmp7_;
4005                 }
4006         }
4007         while (TRUE) {
4008                 gint _tmp16_;
4009                 GeeHashMap* _tmp17_;
4010                 gint _tmp18_;
4011                 while (TRUE) {
4012                         GeeHashMapNode* _tmp8_;
4013                         GeeHashMapNode* _tmp9_;
4014                         GeeForallFunc _tmp10_;
4015                         void* _tmp10__target;
4016                         GeeHashMapNode* _tmp11_;
4017                         GeeMapEntry* _tmp12_ = NULL;
4018                         gboolean _tmp13_ = FALSE;
4019                         GeeHashMapNode* _tmp14_;
4020                         GeeHashMapNode* _tmp15_;
4021                         _tmp8_ = ((GeeHashMapNodeIterator*) self)->_next;
4022                         if (!(_tmp8_ != NULL)) {
4023                                 break;
4024                         }
4025                         _tmp9_ = ((GeeHashMapNodeIterator*) self)->_next;
4026                         ((GeeHashMapNodeIterator*) self)->_node = _tmp9_;
4027                         _tmp10_ = f;
4028                         _tmp10__target = f_target;
4029                         _tmp11_ = ((GeeHashMapNodeIterator*) self)->_node;
4030                         _tmp12_ = gee_hash_map_entry_entry_for (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp11_);
4031                         _tmp13_ = _tmp10_ (_tmp12_, _tmp10__target);
4032                         if (!_tmp13_) {
4033                                 result = FALSE;
4034                                 return result;
4035                         }
4036                         _tmp14_ = ((GeeHashMapNodeIterator*) self)->_next;
4037                         _tmp15_ = _tmp14_->next;
4038                         ((GeeHashMapNodeIterator*) self)->_next = _tmp15_;
4039                 }
4040                 _tmp16_ = ((GeeHashMapNodeIterator*) self)->_index;
4041                 _tmp17_ = ((GeeHashMapNodeIterator*) self)->_map;
4042                 _tmp18_ = _tmp17_->priv->_array_size;
4043                 if ((_tmp16_ + 1) < _tmp18_) {
4044                         GeeHashMap* _tmp19_;
4045                         GeeHashMapNode** _tmp20_;
4046                         gint _tmp20__length1;
4047                         gint _tmp21_;
4048                         gint _tmp22_;
4049                         GeeHashMapNode* _tmp23_;
4050                         _tmp19_ = ((GeeHashMapNodeIterator*) self)->_map;
4051                         _tmp20_ = _tmp19_->priv->_nodes;
4052                         _tmp20__length1 = _tmp19_->priv->_nodes_length1;
4053                         _tmp21_ = ((GeeHashMapNodeIterator*) self)->_index;
4054                         ((GeeHashMapNodeIterator*) self)->_index = _tmp21_ + 1;
4055                         _tmp22_ = ((GeeHashMapNodeIterator*) self)->_index;
4056                         _tmp23_ = _tmp20_[_tmp22_];
4057                         ((GeeHashMapNodeIterator*) self)->_next = _tmp23_;
4058                 } else {
4059                         result = TRUE;
4060                         return result;
4061                 }
4062         }
4063 }
4064
4065
4066 static void gee_hash_map_entry_iterator_class_init (GeeHashMapEntryIteratorClass * klass) {
4067         gee_hash_map_entry_iterator_parent_class = g_type_class_peek_parent (klass);
4068         g_type_class_add_private (klass, sizeof (GeeHashMapEntryIteratorPrivate));
4069         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_entry_iterator_get_property;
4070         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_entry_iterator_set_property;
4071         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_ITERATOR_K_TYPE, g_param_spec_gtype ("k-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));
4072         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-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));
4073         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
4074         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_ITERATOR_V_TYPE, g_param_spec_gtype ("v-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));
4075         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-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));
4076         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRY_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
4077 }
4078
4079
4080 static GType gee_hash_map_entry_iterator_gee_traversable_get_g_type (GeeHashMapEntryIterator* self) {
4081         return GEE_MAP_TYPE_ENTRY;
4082 }
4083
4084
4085 static GBoxedCopyFunc gee_hash_map_entry_iterator_gee_traversable_get_g_dup_func (GeeHashMapEntryIterator* self) {
4086         return g_object_ref;
4087 }
4088
4089
4090 static GDestroyNotify gee_hash_map_entry_iterator_gee_traversable_get_g_destroy_func (GeeHashMapEntryIterator* self) {
4091         return g_object_unref;
4092 }
4093
4094
4095 static void gee_hash_map_entry_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
4096         gee_hash_map_entry_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
4097         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_hash_map_entry_iterator_real_foreach;
4098         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_hash_map_entry_iterator_gee_traversable_get_g_type;
4099         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_hash_map_entry_iterator_gee_traversable_get_g_dup_func;
4100         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_hash_map_entry_iterator_gee_traversable_get_g_destroy_func;
4101 }
4102
4103
4104 static void gee_hash_map_entry_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
4105         gee_hash_map_entry_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
4106         iface->get = (gpointer (*)(GeeIterator*)) gee_hash_map_entry_iterator_real_get;
4107         iface->remove = (void (*)(GeeIterator*)) gee_hash_map_entry_iterator_real_remove;
4108         iface->next = (gboolean (*)(GeeIterator*)) gee_hash_map_node_iterator_next;
4109         iface->has_next = (gboolean (*)(GeeIterator*)) gee_hash_map_node_iterator_has_next;
4110         iface->get_valid = (gboolean (*) (GeeIterator *)) gee_hash_map_node_iterator_get_valid;
4111         iface->get_read_only = (gboolean (*) (GeeIterator *)) gee_hash_map_node_iterator_get_read_only;
4112 }
4113
4114
4115 static void gee_hash_map_entry_iterator_instance_init (GeeHashMapEntryIterator * self) {
4116         self->priv = GEE_HASH_MAP_ENTRY_ITERATOR_GET_PRIVATE (self);
4117 }
4118
4119
4120 static GType gee_hash_map_entry_iterator_get_type (void) {
4121         static volatile gsize gee_hash_map_entry_iterator_type_id__volatile = 0;
4122         if (g_once_init_enter (&gee_hash_map_entry_iterator_type_id__volatile)) {
4123                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapEntryIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_entry_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMapEntryIterator), 0, (GInstanceInitFunc) gee_hash_map_entry_iterator_instance_init, NULL };
4124                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_hash_map_entry_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4125                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_hash_map_entry_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4126                 GType gee_hash_map_entry_iterator_type_id;
4127                 gee_hash_map_entry_iterator_type_id = g_type_register_static (GEE_HASH_MAP_TYPE_NODE_ITERATOR, "GeeHashMapEntryIterator", &g_define_type_info, 0);
4128                 g_type_add_interface_static (gee_hash_map_entry_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
4129                 g_type_add_interface_static (gee_hash_map_entry_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
4130                 g_once_init_leave (&gee_hash_map_entry_iterator_type_id__volatile, gee_hash_map_entry_iterator_type_id);
4131         }
4132         return gee_hash_map_entry_iterator_type_id__volatile;
4133 }
4134
4135
4136 static void _vala_gee_hash_map_entry_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
4137         GeeHashMapEntryIterator * self;
4138         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_ENTRY_ITERATOR, GeeHashMapEntryIterator);
4139         switch (property_id) {
4140                 default:
4141                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4142                 break;
4143         }
4144 }
4145
4146
4147 static void _vala_gee_hash_map_entry_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
4148         GeeHashMapEntryIterator * self;
4149         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_HASH_MAP_TYPE_ENTRY_ITERATOR, GeeHashMapEntryIterator);
4150         switch (property_id) {
4151                 case GEE_HASH_MAP_ENTRY_ITERATOR_K_TYPE:
4152                 self->priv->k_type = g_value_get_gtype (value);
4153                 break;
4154                 case GEE_HASH_MAP_ENTRY_ITERATOR_K_DUP_FUNC:
4155                 self->priv->k_dup_func = g_value_get_pointer (value);
4156                 break;
4157                 case GEE_HASH_MAP_ENTRY_ITERATOR_K_DESTROY_FUNC:
4158                 self->priv->k_destroy_func = g_value_get_pointer (value);
4159                 break;
4160                 case GEE_HASH_MAP_ENTRY_ITERATOR_V_TYPE:
4161                 self->priv->v_type = g_value_get_gtype (value);
4162                 break;
4163                 case GEE_HASH_MAP_ENTRY_ITERATOR_V_DUP_FUNC:
4164                 self->priv->v_dup_func = g_value_get_pointer (value);
4165                 break;
4166                 case GEE_HASH_MAP_ENTRY_ITERATOR_V_DESTROY_FUNC:
4167                 self->priv->v_destroy_func = g_value_get_pointer (value);
4168                 break;
4169                 default:
4170                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4171                 break;
4172         }
4173 }
4174
4175
4176 static void gee_hash_map_class_init (GeeHashMapClass * klass) {
4177         gee_hash_map_parent_class = g_type_class_peek_parent (klass);
4178         g_type_class_add_private (klass, sizeof (GeeHashMapPrivate));
4179         GEE_ABSTRACT_MAP_CLASS (klass)->has_key = gee_hash_map_real_has_key;
4180         GEE_ABSTRACT_MAP_CLASS (klass)->has = gee_hash_map_real_has;
4181         GEE_ABSTRACT_MAP_CLASS (klass)->get = gee_hash_map_real_get;
4182         GEE_ABSTRACT_MAP_CLASS (klass)->set = gee_hash_map_real_set;
4183         GEE_ABSTRACT_MAP_CLASS (klass)->unset = gee_hash_map_real_unset;
4184         GEE_ABSTRACT_MAP_CLASS (klass)->clear = gee_hash_map_real_clear;
4185         GEE_ABSTRACT_MAP_CLASS (klass)->map_iterator = gee_hash_map_real_map_iterator;
4186         GEE_ABSTRACT_MAP_CLASS (klass)->get_size = gee_hash_map_real_get_size;
4187         GEE_ABSTRACT_MAP_CLASS (klass)->get_read_only = gee_hash_map_real_get_read_only;
4188         GEE_ABSTRACT_MAP_CLASS (klass)->get_keys = gee_hash_map_real_get_keys;
4189         GEE_ABSTRACT_MAP_CLASS (klass)->get_values = gee_hash_map_real_get_values;
4190         GEE_ABSTRACT_MAP_CLASS (klass)->get_entries = gee_hash_map_real_get_entries;
4191         G_OBJECT_CLASS (klass)->get_property = _vala_gee_hash_map_get_property;
4192         G_OBJECT_CLASS (klass)->set_property = _vala_gee_hash_map_set_property;
4193         G_OBJECT_CLASS (klass)->finalize = gee_hash_map_finalize;
4194         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_K_TYPE, g_param_spec_gtype ("k-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));
4195         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_K_DUP_FUNC, g_param_spec_pointer ("k-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));
4196         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_K_DESTROY_FUNC, g_param_spec_pointer ("k-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));
4197         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_V_TYPE, g_param_spec_gtype ("v-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));
4198         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_V_DUP_FUNC, g_param_spec_pointer ("v-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));
4199         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_V_DESTROY_FUNC, g_param_spec_pointer ("v-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));
4200         /**
4201          * {@inheritDoc}
4202          */
4203         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_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));
4204         /**
4205          * {@inheritDoc}
4206          */
4207         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_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));
4208         /**
4209          * {@inheritDoc}
4210          */
4211         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_KEYS, g_param_spec_object ("keys", "keys", "keys", GEE_TYPE_SET, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
4212         /**
4213          * {@inheritDoc}
4214          */
4215         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_VALUES, g_param_spec_object ("values", "values", "values", GEE_TYPE_COLLECTION, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
4216         /**
4217          * {@inheritDoc}
4218          */
4219         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_HASH_MAP_ENTRIES, g_param_spec_object ("entries", "entries", "entries", GEE_TYPE_SET, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
4220 }
4221
4222
4223 static void gee_hash_map_instance_init (GeeHashMap * self) {
4224         self->priv = GEE_HASH_MAP_GET_PRIVATE (self);
4225         self->priv->_stamp = 0;
4226 }
4227
4228
4229 static void gee_hash_map_finalize (GObject* obj) {
4230         GeeHashMap * self;
4231         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_HASH_MAP, GeeHashMap);
4232         gee_abstract_map_clear ((GeeAbstractMap*) self);
4233         (self->priv->_key_hash_func_target_destroy_notify == NULL) ? NULL : (self->priv->_key_hash_func_target_destroy_notify (self->priv->_key_hash_func_target), NULL);
4234         self->priv->_key_hash_func = NULL;
4235         self->priv->_key_hash_func_target = NULL;
4236         self->priv->_key_hash_func_target_destroy_notify = NULL;
4237         (self->priv->_key_equal_func_target_destroy_notify == NULL) ? NULL : (self->priv->_key_equal_func_target_destroy_notify (self->priv->_key_equal_func_target), NULL);
4238         self->priv->_key_equal_func = NULL;
4239         self->priv->_key_equal_func_target = NULL;
4240         self->priv->_key_equal_func_target_destroy_notify = NULL;
4241         (self->priv->_value_equal_func_target_destroy_notify == NULL) ? NULL : (self->priv->_value_equal_func_target_destroy_notify (self->priv->_value_equal_func_target), NULL);
4242         self->priv->_value_equal_func = NULL;
4243         self->priv->_value_equal_func_target = NULL;
4244         self->priv->_value_equal_func_target_destroy_notify = NULL;
4245         self->priv->_nodes = (_vala_array_free (self->priv->_nodes, self->priv->_nodes_length1, (GDestroyNotify) gee_hash_map_node_free), NULL);
4246         G_OBJECT_CLASS (gee_hash_map_parent_class)->finalize (obj);
4247 }
4248
4249
4250 /**
4251  * Hash table implementation of the {@link Map} interface.
4252  *
4253  * This implementation is better fit for highly heterogenous key values.
4254  * In case of high key hashes redundancy or higher amount of data prefer using
4255  * tree implementation like {@link TreeMap}.
4256  *
4257  * @see TreeMap
4258  */
4259 GType gee_hash_map_get_type (void) {
4260         static volatile gsize gee_hash_map_type_id__volatile = 0;
4261         if (g_once_init_enter (&gee_hash_map_type_id__volatile)) {
4262                 static const GTypeInfo g_define_type_info = { sizeof (GeeHashMapClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_hash_map_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeHashMap), 0, (GInstanceInitFunc) gee_hash_map_instance_init, NULL };
4263                 GType gee_hash_map_type_id;
4264                 gee_hash_map_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_MAP, "GeeHashMap", &g_define_type_info, 0);
4265                 g_once_init_leave (&gee_hash_map_type_id__volatile, gee_hash_map_type_id);
4266         }
4267         return gee_hash_map_type_id__volatile;
4268 }
4269
4270
4271 static void _vala_gee_hash_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
4272         GeeHashMap * self;
4273         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_HASH_MAP, GeeHashMap);
4274         switch (property_id) {
4275                 case GEE_HASH_MAP_SIZE:
4276                 g_value_set_int (value, gee_abstract_map_get_size ((GeeAbstractMap*) self));
4277                 break;
4278                 case GEE_HASH_MAP_READ_ONLY:
4279                 g_value_set_boolean (value, gee_abstract_map_get_read_only ((GeeAbstractMap*) self));
4280                 break;
4281                 case GEE_HASH_MAP_KEYS:
4282                 g_value_take_object (value, gee_abstract_map_get_keys ((GeeAbstractMap*) self));
4283                 break;
4284                 case GEE_HASH_MAP_VALUES:
4285                 g_value_take_object (value, gee_abstract_map_get_values ((GeeAbstractMap*) self));
4286                 break;
4287                 case GEE_HASH_MAP_ENTRIES:
4288                 g_value_take_object (value, gee_abstract_map_get_entries ((GeeAbstractMap*) self));
4289                 break;
4290                 default:
4291                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4292                 break;
4293         }
4294 }
4295
4296
4297 static void _vala_gee_hash_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
4298         GeeHashMap * self;
4299         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_HASH_MAP, GeeHashMap);
4300         switch (property_id) {
4301                 case GEE_HASH_MAP_K_TYPE:
4302                 self->priv->k_type = g_value_get_gtype (value);
4303                 break;
4304                 case GEE_HASH_MAP_K_DUP_FUNC:
4305                 self->priv->k_dup_func = g_value_get_pointer (value);
4306                 break;
4307                 case GEE_HASH_MAP_K_DESTROY_FUNC:
4308                 self->priv->k_destroy_func = g_value_get_pointer (value);
4309                 break;
4310                 case GEE_HASH_MAP_V_TYPE:
4311                 self->priv->v_type = g_value_get_gtype (value);
4312                 break;
4313                 case GEE_HASH_MAP_V_DUP_FUNC:
4314                 self->priv->v_dup_func = g_value_get_pointer (value);
4315                 break;
4316                 case GEE_HASH_MAP_V_DESTROY_FUNC:
4317                 self->priv->v_destroy_func = g_value_get_pointer (value);
4318                 break;
4319                 default:
4320                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4321                 break;
4322         }
4323 }
4324
4325
4326 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
4327         if ((array != NULL) && (destroy_func != NULL)) {
4328                 int i;
4329                 for (i = 0; i < array_length; i = i + 1) {
4330                         if (((gpointer*) array)[i] != NULL) {
4331                                 destroy_func (((gpointer*) array)[i]);
4332                         }
4333                 }
4334         }
4335 }
4336
4337
4338 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
4339         _vala_array_destroy (array, array_length, destroy_func);
4340         g_free (array);
4341 }
4342
4343
4344