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