gee/abstractmap.c

   1 /* abstractmap.c generated by valac 0.18.0, the Vala compiler
   2  * generated from abstractmap.vala, do not modify */
   3
   4 /* abstractmap.vala
   5  *
   6  * Copyright (C) 2007  Jürg Billeter
   7  * Copyright (C) 2009  Didier Villevalois
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  22  *
  23  * Author:
  24  *      Tomaž Vajngerl <quikee@gmail.com>
  25  */
  26
  27 #include <glib.h>
  28 #include <glib-object.h>
  29
  30
  31 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  32 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  33 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  34 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  35
  36 typedef struct _GeeTraversable GeeTraversable;
  37 typedef struct _GeeTraversableIface GeeTraversableIface;
  38
  39 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  40
  41 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  42 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  43 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  44 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  45 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  46 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  47
  48 typedef struct _GeeLazy GeeLazy;
  49 typedef struct _GeeLazyClass GeeLazyClass;
  50
  51 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  52 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  53 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  54 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  55
  56 typedef struct _GeeIterator GeeIterator;
  57 typedef struct _GeeIteratorIface GeeIteratorIface;
  58
  59 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  60 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  61 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  62 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  63
  64 typedef struct _GeeIterable GeeIterable;
  65 typedef struct _GeeIterableIface GeeIterableIface;
  66
  67 #define GEE_TYPE_MAP (gee_map_get_type ())
  68 #define GEE_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP, GeeMap))
  69 #define GEE_IS_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP))
  70 #define GEE_MAP_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP, GeeMapIface))
  71
  72 typedef struct _GeeMap GeeMap;
  73 typedef struct _GeeMapIface GeeMapIface;
  74
  75 #define GEE_TYPE_MAP_ITERATOR (gee_map_iterator_get_type ())
  76 #define GEE_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIterator))
  77 #define GEE_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP_ITERATOR))
  78 #define GEE_MAP_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIteratorIface))
  79
  80 typedef struct _GeeMapIterator GeeMapIterator;
  81 typedef struct _GeeMapIteratorIface GeeMapIteratorIface;
  82
  83 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  84 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  85 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  86 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  87
  88 typedef struct _GeeCollection GeeCollection;
  89 typedef struct _GeeCollectionIface GeeCollectionIface;
  90
  91 #define GEE_TYPE_SET (gee_set_get_type ())
  92 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
  93 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
  94 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
  95
  96 typedef struct _GeeSet GeeSet;
  97 typedef struct _GeeSetIface GeeSetIface;
  98
  99 #define GEE_MAP_TYPE_ENTRY (gee_map_entry_get_type ())
 100 #define GEE_MAP_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntry))
 101 #define GEE_MAP_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 102 #define GEE_MAP_IS_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_MAP_TYPE_ENTRY))
 103 #define GEE_MAP_IS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_MAP_TYPE_ENTRY))
 104 #define GEE_MAP_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 105
 106 typedef struct _GeeMapEntry GeeMapEntry;
 107 typedef struct _GeeMapEntryClass GeeMapEntryClass;
 108
 109 #define GEE_TYPE_ABSTRACT_MAP (gee_abstract_map_get_type ())
 110 #define GEE_ABSTRACT_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_MAP, GeeAbstractMap))
 111 #define GEE_ABSTRACT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_MAP, GeeAbstractMapClass))
 112 #define GEE_IS_ABSTRACT_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_MAP))
 113 #define GEE_IS_ABSTRACT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_MAP))
 114 #define GEE_ABSTRACT_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_MAP, GeeAbstractMapClass))
 115
 116 typedef struct _GeeAbstractMap GeeAbstractMap;
 117 typedef struct _GeeAbstractMapClass GeeAbstractMapClass;
 118 typedef struct _GeeAbstractMapPrivate GeeAbstractMapPrivate;
 119 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 120
 121 #define GEE_TYPE_READ_ONLY_MAP (gee_read_only_map_get_type ())
 122 #define GEE_READ_ONLY_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMap))
 123 #define GEE_READ_ONLY_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMapClass))
 124 #define GEE_IS_READ_ONLY_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_MAP))
 125 #define GEE_IS_READ_ONLY_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_MAP))
 126 #define GEE_READ_ONLY_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMapClass))
 127
 128 typedef struct _GeeReadOnlyMap GeeReadOnlyMap;
 129 typedef struct _GeeReadOnlyMapClass GeeReadOnlyMapClass;
 130
 131 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 132 typedef enum  {
 133         GEE_TRAVERSABLE_STREAM_YIELD,
 134         GEE_TRAVERSABLE_STREAM_CONTINUE,
 135         GEE_TRAVERSABLE_STREAM_END
 136 } GeeTraversableStream;
 137
 138 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 139 struct _GeeIteratorIface {
 140         GTypeInterface parent_iface;
 141         gboolean (*next) (GeeIterator* self);
 142         gboolean (*has_next) (GeeIterator* self);
 143         gpointer (*get) (GeeIterator* self);
 144         void (*remove) (GeeIterator* self);
 145         gboolean (*get_valid) (GeeIterator* self);
 146         gboolean (*get_read_only) (GeeIterator* self);
 147 };
 148
 149 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 150 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 151 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 152 struct _GeeTraversableIface {
 153         GTypeInterface parent_iface;
 154         GType (*get_g_type) (GeeTraversable* self);
 155         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 156         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 157         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 158         GeeIterator* (*stream) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 159         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 160         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 161         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 162         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 163         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 164         GType (*get_element_type) (GeeTraversable* self);
 165 };
 166
 167 struct _GeeIterableIface {
 168         GTypeInterface parent_iface;
 169         GType (*get_g_type) (GeeIterable* self);
 170         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 171         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 172         GeeIterator* (*iterator) (GeeIterable* self);
 173 };
 174
 175 typedef gpointer (*GeeFoldMapFunc) (gconstpointer k, gconstpointer v, gpointer a, void* user_data);
 176 typedef gboolean (*GeeForallMapFunc) (gconstpointer k, gconstpointer v, void* user_data);
 177 struct _GeeMapIteratorIface {
 178         GTypeInterface parent_iface;
 179         GType (*get_k_type) (GeeMapIterator* self);
 180         GBoxedCopyFunc (*get_k_dup_func) (GeeMapIterator* self);
 181         GDestroyNotify (*get_k_destroy_func) (GeeMapIterator* self);
 182         GType (*get_v_type) (GeeMapIterator* self);
 183         GBoxedCopyFunc (*get_v_dup_func) (GeeMapIterator* self);
 184         GDestroyNotify (*get_v_destroy_func) (GeeMapIterator* self);
 185         gboolean (*next) (GeeMapIterator* self);
 186         gboolean (*has_next) (GeeMapIterator* self);
 187         gpointer (*get_key) (GeeMapIterator* self);
 188         gpointer (*get_value) (GeeMapIterator* self);
 189         void (*set_value) (GeeMapIterator* self, gconstpointer value);
 190         void (*unset) (GeeMapIterator* self);
 191         gpointer (*fold) (GeeMapIterator* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldMapFunc f, void* f_target, gpointer seed);
 192         gboolean (*foreach) (GeeMapIterator* self, GeeForallMapFunc f, void* f_target);
 193         gboolean (*get_valid) (GeeMapIterator* self);
 194         gboolean (*get_mutable) (GeeMapIterator* self);
 195         gboolean (*get_read_only) (GeeMapIterator* self);
 196 };
 197
 198 struct _GeeCollectionIface {
 199         GTypeInterface parent_iface;
 200         GType (*get_g_type) (GeeCollection* self);
 201         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 202         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 203         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 204         gboolean (*add) (GeeCollection* self, gconstpointer item);
 205         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 206         void (*clear) (GeeCollection* self);
 207         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 208         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 209         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 210         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 211         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 212         gint (*get_size) (GeeCollection* self);
 213         gboolean (*get_is_empty) (GeeCollection* self);
 214         gboolean (*get_read_only) (GeeCollection* self);
 215         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 216 };
 217
 218 struct _GeeSetIface {
 219         GTypeInterface parent_iface;
 220         GType (*get_g_type) (GeeSet* self);
 221         GBoxedCopyFunc (*get_g_dup_func) (GeeSet* self);
 222         GDestroyNotify (*get_g_destroy_func) (GeeSet* self);
 223         GeeSet* (*get_read_only_view) (GeeSet* self);
 224 };
 225
 226 struct _GeeMapIface {
 227         GTypeInterface parent_iface;
 228         GType (*get_k_type) (GeeMap* self);
 229         GBoxedCopyFunc (*get_k_dup_func) (GeeMap* self);
 230         GDestroyNotify (*get_k_destroy_func) (GeeMap* self);
 231         GType (*get_v_type) (GeeMap* self);
 232         GBoxedCopyFunc (*get_v_dup_func) (GeeMap* self);
 233         GDestroyNotify (*get_v_destroy_func) (GeeMap* self);
 234         gboolean (*has_key) (GeeMap* self, gconstpointer key);
 235         gboolean (*has) (GeeMap* self, gconstpointer key, gconstpointer value);
 236         gpointer (*get) (GeeMap* self, gconstpointer key);
 237         void (*set) (GeeMap* self, gconstpointer key, gconstpointer value);
 238         gboolean (*unset) (GeeMap* self, gconstpointer key, gpointer* value);
 239         void (*clear) (GeeMap* self);
 240         GeeMapIterator* (*map_iterator) (GeeMap* self);
 241         void (*set_all) (GeeMap* self, GeeMap* map);
 242         gboolean (*unset_all) (GeeMap* self, GeeMap* map);
 243         gboolean (*has_all) (GeeMap* self, GeeMap* map);
 244         gint (*get_size) (GeeMap* self);
 245         gboolean (*get_is_empty) (GeeMap* self);
 246         gboolean (*get_read_only) (GeeMap* self);
 247         GeeSet* (*get_keys) (GeeMap* self);
 248         GeeCollection* (*get_values) (GeeMap* self);
 249         GeeSet* (*get_entries) (GeeMap* self);
 250         GeeMap* (*get_read_only_view) (GeeMap* self);
 251 };
 252
 253 struct _GeeAbstractMap {
 254         GObject parent_instance;
 255         GeeAbstractMapPrivate * priv;
 256 };
 257
 258 struct _GeeAbstractMapClass {
 259         GObjectClass parent_class;
 260         gboolean (*has_key) (GeeAbstractMap* self, gconstpointer key);
 261         gboolean (*has) (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 262         gpointer (*get) (GeeAbstractMap* self, gconstpointer key);
 263         void (*set) (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 264         gboolean (*unset) (GeeAbstractMap* self, gconstpointer key, gpointer* value);
 265         GeeMapIterator* (*map_iterator) (GeeAbstractMap* self);
 266         void (*clear) (GeeAbstractMap* self);
 267         gboolean (*foreach) (GeeAbstractMap* self, GeeForallFunc f, void* f_target);
 268         GeeIterator* (*stream) (GeeAbstractMap* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 269         void (*reserved0) (GeeAbstractMap* self);
 270         void (*reserved1) (GeeAbstractMap* self);
 271         void (*reserved2) (GeeAbstractMap* self);
 272         void (*reserved3) (GeeAbstractMap* self);
 273         void (*reserved4) (GeeAbstractMap* self);
 274         void (*reserved5) (GeeAbstractMap* self);
 275         void (*reserved6) (GeeAbstractMap* self);
 276         void (*reserved7) (GeeAbstractMap* self);
 277         void (*reserved8) (GeeAbstractMap* self);
 278         void (*reserved9) (GeeAbstractMap* self);
 279         gint (*get_size) (GeeAbstractMap* self);
 280         gboolean (*get_read_only) (GeeAbstractMap* self);
 281         GeeSet* (*get_keys) (GeeAbstractMap* self);
 282         GeeCollection* (*get_values) (GeeAbstractMap* self);
 283         GeeSet* (*get_entries) (GeeAbstractMap* self);
 284         GeeMap* (*get_read_only_view) (GeeAbstractMap* self);
 285 };
 286
 287 struct _GeeAbstractMapPrivate {
 288         GType k_type;
 289         GBoxedCopyFunc k_dup_func;
 290         GDestroyNotify k_destroy_func;
 291         GType v_type;
 292         GBoxedCopyFunc v_dup_func;
 293         GDestroyNotify v_destroy_func;
 294         GeeMap* _read_only_view;
 295 };
 296
 297
 298 static gpointer gee_abstract_map_parent_class = NULL;
 299 static GeeTraversableIface* gee_abstract_map_gee_traversable_parent_iface = NULL;
 300 static GeeIterableIface* gee_abstract_map_gee_iterable_parent_iface = NULL;
 301 static GeeMapIface* gee_abstract_map_gee_map_parent_iface = NULL;
 302
 303 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 304 gpointer gee_lazy_ref (gpointer instance);
 305 void gee_lazy_unref (gpointer instance);
 306 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 307 void gee_value_set_lazy (GValue* value, gpointer v_object);
 308 void gee_value_take_lazy (GValue* value, gpointer v_object);
 309 gpointer gee_value_get_lazy (const GValue* value);
 310 GType gee_lazy_get_type (void) G_GNUC_CONST;
 311 GType gee_iterator_get_type (void) G_GNUC_CONST;
 312 GType gee_traversable_get_type (void) G_GNUC_CONST;
 313 GType gee_iterable_get_type (void) G_GNUC_CONST;
 314 GType gee_map_iterator_get_type (void) G_GNUC_CONST;
 315 GType gee_collection_get_type (void) G_GNUC_CONST;
 316 GType gee_set_get_type (void) G_GNUC_CONST;
 317 GType gee_map_entry_get_type (void) G_GNUC_CONST;
 318 GType gee_map_get_type (void) G_GNUC_CONST;
 319 GType gee_abstract_map_get_type (void) G_GNUC_CONST;
 320 #define GEE_ABSTRACT_MAP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_ABSTRACT_MAP, GeeAbstractMapPrivate))
 321 enum  {
 322         GEE_ABSTRACT_MAP_DUMMY_PROPERTY,
 323         GEE_ABSTRACT_MAP_K_TYPE,
 324         GEE_ABSTRACT_MAP_K_DUP_FUNC,
 325         GEE_ABSTRACT_MAP_K_DESTROY_FUNC,
 326         GEE_ABSTRACT_MAP_V_TYPE,
 327         GEE_ABSTRACT_MAP_V_DUP_FUNC,
 328         GEE_ABSTRACT_MAP_V_DESTROY_FUNC,
 329         GEE_ABSTRACT_MAP_SIZE,
 330         GEE_ABSTRACT_MAP_READ_ONLY,
 331         GEE_ABSTRACT_MAP_KEYS,
 332         GEE_ABSTRACT_MAP_VALUES,
 333         GEE_ABSTRACT_MAP_ENTRIES,
 334         GEE_ABSTRACT_MAP_READ_ONLY_VIEW
 335 };
 336 gboolean gee_abstract_map_has_key (GeeAbstractMap* self, gconstpointer key);
 337 static gboolean gee_abstract_map_real_has_key (GeeAbstractMap* self, gconstpointer key);
 338 gboolean gee_abstract_map_has (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 339 static gboolean gee_abstract_map_real_has (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 340 gpointer gee_abstract_map_get (GeeAbstractMap* self, gconstpointer key);
 341 static gpointer gee_abstract_map_real_get (GeeAbstractMap* self, gconstpointer key);
 342 void gee_abstract_map_set (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 343 static void gee_abstract_map_real_set (GeeAbstractMap* self, gconstpointer key, gconstpointer value);
 344 gboolean gee_abstract_map_unset (GeeAbstractMap* self, gconstpointer key, gpointer* value);
 345 static gboolean gee_abstract_map_real_unset (GeeAbstractMap* self, gconstpointer key, gpointer* value);
 346 GeeMapIterator* gee_abstract_map_map_iterator (GeeAbstractMap* self);
 347 static GeeMapIterator* gee_abstract_map_real_map_iterator (GeeAbstractMap* self);
 348 void gee_abstract_map_clear (GeeAbstractMap* self);
 349 static void gee_abstract_map_real_clear (GeeAbstractMap* self);
 350 static GeeIterator* gee_abstract_map_real_iterator (GeeIterable* base);
 351 GeeSet* gee_map_get_entries (GeeMap* self);
 352 GeeIterator* gee_iterable_iterator (GeeIterable* self);
 353 gboolean gee_abstract_map_foreach (GeeAbstractMap* self, GeeForallFunc f, void* f_target);
 354 static gboolean gee_abstract_map_real_foreach (GeeAbstractMap* self, GeeForallFunc f, void* f_target);
 355 gboolean gee_traversable_foreach (GeeTraversable* self, GeeForallFunc f, void* f_target);
 356 GeeIterator* gee_abstract_map_stream (GeeAbstractMap* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 357 static GeeIterator* gee_abstract_map_real_stream (GeeAbstractMap* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 358 GeeIterator* gee_traversable_stream (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 359 void gee_abstract_map_reserved0 (GeeAbstractMap* self);
 360 static void gee_abstract_map_real_reserved0 (GeeAbstractMap* self);
 361 void gee_abstract_map_reserved1 (GeeAbstractMap* self);
 362 static void gee_abstract_map_real_reserved1 (GeeAbstractMap* self);
 363 void gee_abstract_map_reserved2 (GeeAbstractMap* self);
 364 static void gee_abstract_map_real_reserved2 (GeeAbstractMap* self);
 365 void gee_abstract_map_reserved3 (GeeAbstractMap* self);
 366 static void gee_abstract_map_real_reserved3 (GeeAbstractMap* self);
 367 void gee_abstract_map_reserved4 (GeeAbstractMap* self);
 368 static void gee_abstract_map_real_reserved4 (GeeAbstractMap* self);
 369 void gee_abstract_map_reserved5 (GeeAbstractMap* self);
 370 static void gee_abstract_map_real_reserved5 (GeeAbstractMap* self);
 371 void gee_abstract_map_reserved6 (GeeAbstractMap* self);
 372 static void gee_abstract_map_real_reserved6 (GeeAbstractMap* self);
 373 void gee_abstract_map_reserved7 (GeeAbstractMap* self);
 374 static void gee_abstract_map_real_reserved7 (GeeAbstractMap* self);
 375 void gee_abstract_map_reserved8 (GeeAbstractMap* self);
 376 static void gee_abstract_map_real_reserved8 (GeeAbstractMap* self);
 377 void gee_abstract_map_reserved9 (GeeAbstractMap* self);
 378 static void gee_abstract_map_real_reserved9 (GeeAbstractMap* self);
 379 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);
 380 gint gee_abstract_map_get_size (GeeAbstractMap* self);
 381 gboolean gee_abstract_map_get_read_only (GeeAbstractMap* self);
 382 GeeSet* gee_abstract_map_get_keys (GeeAbstractMap* self);
 383 GeeCollection* gee_abstract_map_get_values (GeeAbstractMap* self);
 384 GeeSet* gee_abstract_map_get_entries (GeeAbstractMap* self);
 385 GeeMap* gee_abstract_map_get_read_only_view (GeeAbstractMap* self);
 386 GeeReadOnlyMap* gee_read_only_map_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMap* map);
 387 GeeReadOnlyMap* gee_read_only_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, GeeMap* map);
 388 GType gee_read_only_map_get_type (void) G_GNUC_CONST;
 389 static void gee_abstract_map_finalize (GObject* obj);
 390 static void _vala_gee_abstract_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 391 static void _vala_gee_abstract_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 392
 393
 394 /**
 395  * {@inheritDoc}
 396  */
 397 static gboolean gee_abstract_map_real_has_key (GeeAbstractMap* self, gconstpointer key) {
 398         g_critical ("Type `%s' does not implement abstract method `gee_abstract_map_has_key'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 399         return FALSE;
 400 }
 401
 402
 403 gboolean gee_abstract_map_has_key (GeeAbstractMap* self, gconstpointer key) {
 404         g_return_val_if_fail (self != NULL, FALSE);
 405         return GEE_ABSTRACT_MAP_GET_CLASS (self)->has_key (self, key);
 406 }
 407
 408
 409 /**
 410  * {@inheritDoc}
 411  */
 412 static gboolean gee_abstract_map_real_has (GeeAbstractMap* self, gconstpointer key, gconstpointer value) {
 413         g_critical ("Type `%s' does not implement abstract method `gee_abstract_map_has'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 414         return FALSE;
 415 }
 416
 417
 418 gboolean gee_abstract_map_has (GeeAbstractMap* self, gconstpointer key, gconstpointer value) {
 419         g_return_val_if_fail (self != NULL, FALSE);
 420         return GEE_ABSTRACT_MAP_GET_CLASS (self)->has (self, key, value);
 421 }
 422
 423
 424 /**
 425  * {@inheritDoc}
 426  */
 427 static gpointer gee_abstract_map_real_get (GeeAbstractMap* self, gconstpointer key) {
 428         g_critical ("Type `%s' does not implement abstract method `gee_abstract_map_get'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 429         return NULL;
 430 }
 431
 432
 433 gpointer gee_abstract_map_get (GeeAbstractMap* self, gconstpointer key) {
 434         g_return_val_if_fail (self != NULL, NULL);
 435         return GEE_ABSTRACT_MAP_GET_CLASS (self)->get (self, key);
 436 }
 437
 438
 439 /**
 440  * {@inheritDoc}
 441  */
 442 static void gee_abstract_map_real_set (GeeAbstractMap* self, gconstpointer key, gconstpointer value) {
 443         g_critical ("Type `%s' does not implement abstract method `gee_abstract_map_set'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 444         return;
 445 }
 446
 447
 448 void gee_abstract_map_set (GeeAbstractMap* self, gconstpointer key, gconstpointer value) {
 449         g_return_if_fail (self != NULL);
 450         GEE_ABSTRACT_MAP_GET_CLASS (self)->set (self, key, value);
 451 }
 452
 453
 454 /**
 455  * {@inheritDoc}
 456  */
 457 static gboolean gee_abstract_map_real_unset (GeeAbstractMap* self, gconstpointer key, gpointer* value) {
 458         g_critical ("Type `%s' does not implement abstract method `gee_abstract_map_unset'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 459         return FALSE;
 460 }
 461
 462
 463 gboolean gee_abstract_map_unset (GeeAbstractMap* self, gconstpointer key, gpointer* value) {
 464         g_return_val_if_fail (self != NULL, FALSE);
 465         return GEE_ABSTRACT_MAP_GET_CLASS (self)->unset (self, key, value);
 466 }
 467
 468
 469 /**
 470  * {@inheritDoc}
 471  */
 472 static GeeMapIterator* gee_abstract_map_real_map_iterator (GeeAbstractMap* self) {
 473         g_critical ("Type `%s' does not implement abstract method `gee_abstract_map_map_iterator'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 474         return NULL;
 475 }
 476
 477
 478 GeeMapIterator* gee_abstract_map_map_iterator (GeeAbstractMap* self) {
 479         g_return_val_if_fail (self != NULL, NULL);
 480         return GEE_ABSTRACT_MAP_GET_CLASS (self)->map_iterator (self);
 481 }
 482
 483
 484 /**
 485  * {@inheritDoc}
 486  */
 487 static void gee_abstract_map_real_clear (GeeAbstractMap* self) {
 488         g_critical ("Type `%s' does not implement abstract method `gee_abstract_map_clear'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
 489         return;
 490 }
 491
 492
 493 void gee_abstract_map_clear (GeeAbstractMap* self) {
 494         g_return_if_fail (self != NULL);
 495         GEE_ABSTRACT_MAP_GET_CLASS (self)->clear (self);
 496 }
 497
 498
 499 /**
 500  * {@inheritDoc}
 501  */
 502 static GeeIterator* gee_abstract_map_real_iterator (GeeIterable* base) {
 503         GeeAbstractMap * self;
 504         GeeIterator* result = NULL;
 505         GeeSet* _tmp0_;
 506         GeeSet* _tmp1_;
 507         GeeSet* _tmp2_;
 508         GeeIterator* _tmp3_ = NULL;
 509         GeeIterator* _tmp4_;
 510         self = (GeeAbstractMap*) base;
 511         _tmp0_ = gee_map_get_entries ((GeeMap*) self);
 512         _tmp1_ = _tmp0_;
 513         _tmp2_ = _tmp1_;
 514         _tmp3_ = gee_iterable_iterator ((GeeIterable*) _tmp2_);
 515         _tmp4_ = _tmp3_;
 516         _g_object_unref0 (_tmp2_);
 517         result = _tmp4_;
 518         return result;
 519 }
 520
 521
 522 /**
 523  * {@inheritDoc}
 524  */
 525 static gboolean gee_abstract_map_real_foreach (GeeAbstractMap* self, GeeForallFunc f, void* f_target) {
 526         gboolean result = FALSE;
 527         GeeIterator* _tmp0_ = NULL;
 528         GeeIterator* _tmp1_;
 529         GeeForallFunc _tmp2_;
 530         void* _tmp2__target;
 531         gboolean _tmp3_ = FALSE;
 532         gboolean _tmp4_;
 533         _tmp0_ = gee_iterable_iterator ((GeeIterable*) self);
 534         _tmp1_ = _tmp0_;
 535         _tmp2_ = f;
 536         _tmp2__target = f_target;
 537         _tmp3_ = gee_traversable_foreach ((GeeTraversable*) _tmp1_, _tmp2_, _tmp2__target);
 538         _tmp4_ = _tmp3_;
 539         _g_object_unref0 (_tmp1_);
 540         result = _tmp4_;
 541         return result;
 542 }
 543
 544
 545 gboolean gee_abstract_map_foreach (GeeAbstractMap* self, GeeForallFunc f, void* f_target) {
 546         g_return_val_if_fail (self != NULL, FALSE);
 547         return GEE_ABSTRACT_MAP_GET_CLASS (self)->foreach (self, f, f_target);
 548 }
 549
 550
 551 /**
 552  * {@inheritDoc}
 553  */
 554 static GeeIterator* gee_abstract_map_real_stream (GeeAbstractMap* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 555         GeeIterator* result = NULL;
 556         GeeIterator* _tmp0_ = NULL;
 557         GeeIterator* _tmp1_;
 558         GeeStreamFunc _tmp2_;
 559         void* _tmp2__target;
 560         GDestroyNotify _tmp2__target_destroy_notify;
 561         GeeIterator* _tmp3_ = NULL;
 562         GeeIterator* _tmp4_;
 563         _tmp0_ = gee_iterable_iterator ((GeeIterable*) self);
 564         _tmp1_ = _tmp0_;
 565         _tmp2_ = f;
 566         _tmp2__target = f_target;
 567         _tmp2__target_destroy_notify = f_target_destroy_notify;
 568         f_target_destroy_notify = NULL;
 569         _tmp3_ = gee_traversable_stream ((GeeTraversable*) _tmp1_, a_type, (GBoxedCopyFunc) a_dup_func, a_destroy_func, _tmp2_, _tmp2__target, _tmp2__target_destroy_notify);
 570         _tmp4_ = _tmp3_;
 571         _g_object_unref0 (_tmp1_);
 572         result = _tmp4_;
 573         (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
 574         f = NULL;
 575         f_target = NULL;
 576         f_target_destroy_notify = NULL;
 577         return result;
 578 }
 579
 580
 581 GeeIterator* gee_abstract_map_stream (GeeAbstractMap* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 582         g_return_val_if_fail (self != NULL, NULL);
 583         return GEE_ABSTRACT_MAP_GET_CLASS (self)->stream (self, a_type, a_dup_func, a_destroy_func, f, f_target, f_target_destroy_notify);
 584 }
 585
 586
 587 static void gee_abstract_map_real_reserved0 (GeeAbstractMap* self) {
 588 }
 589
 590
 591 void gee_abstract_map_reserved0 (GeeAbstractMap* self) {
 592         g_return_if_fail (self != NULL);
 593         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved0 (self);
 594 }
 595
 596
 597 static void gee_abstract_map_real_reserved1 (GeeAbstractMap* self) {
 598 }
 599
 600
 601 void gee_abstract_map_reserved1 (GeeAbstractMap* self) {
 602         g_return_if_fail (self != NULL);
 603         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved1 (self);
 604 }
 605
 606
 607 static void gee_abstract_map_real_reserved2 (GeeAbstractMap* self) {
 608 }
 609
 610
 611 void gee_abstract_map_reserved2 (GeeAbstractMap* self) {
 612         g_return_if_fail (self != NULL);
 613         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved2 (self);
 614 }
 615
 616
 617 static void gee_abstract_map_real_reserved3 (GeeAbstractMap* self) {
 618 }
 619
 620
 621 void gee_abstract_map_reserved3 (GeeAbstractMap* self) {
 622         g_return_if_fail (self != NULL);
 623         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved3 (self);
 624 }
 625
 626
 627 static void gee_abstract_map_real_reserved4 (GeeAbstractMap* self) {
 628 }
 629
 630
 631 void gee_abstract_map_reserved4 (GeeAbstractMap* self) {
 632         g_return_if_fail (self != NULL);
 633         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved4 (self);
 634 }
 635
 636
 637 static void gee_abstract_map_real_reserved5 (GeeAbstractMap* self) {
 638 }
 639
 640
 641 void gee_abstract_map_reserved5 (GeeAbstractMap* self) {
 642         g_return_if_fail (self != NULL);
 643         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved5 (self);
 644 }
 645
 646
 647 static void gee_abstract_map_real_reserved6 (GeeAbstractMap* self) {
 648 }
 649
 650
 651 void gee_abstract_map_reserved6 (GeeAbstractMap* self) {
 652         g_return_if_fail (self != NULL);
 653         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved6 (self);
 654 }
 655
 656
 657 static void gee_abstract_map_real_reserved7 (GeeAbstractMap* self) {
 658 }
 659
 660
 661 void gee_abstract_map_reserved7 (GeeAbstractMap* self) {
 662         g_return_if_fail (self != NULL);
 663         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved7 (self);
 664 }
 665
 666
 667 static void gee_abstract_map_real_reserved8 (GeeAbstractMap* self) {
 668 }
 669
 670
 671 void gee_abstract_map_reserved8 (GeeAbstractMap* self) {
 672         g_return_if_fail (self != NULL);
 673         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved8 (self);
 674 }
 675
 676
 677 static void gee_abstract_map_real_reserved9 (GeeAbstractMap* self) {
 678 }
 679
 680
 681 void gee_abstract_map_reserved9 (GeeAbstractMap* self) {
 682         g_return_if_fail (self != NULL);
 683         GEE_ABSTRACT_MAP_GET_CLASS (self)->reserved9 (self);
 684 }
 685
 686
 687 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) {
 688         GeeAbstractMap * self = NULL;
 689         self = (GeeAbstractMap*) g_object_new (object_type, NULL);
 690         self->priv->k_type = k_type;
 691         self->priv->k_dup_func = k_dup_func;
 692         self->priv->k_destroy_func = k_destroy_func;
 693         self->priv->v_type = v_type;
 694         self->priv->v_dup_func = v_dup_func;
 695         self->priv->v_destroy_func = v_destroy_func;
 696         return self;
 697 }
 698
 699
 700 gint gee_abstract_map_get_size (GeeAbstractMap* self) {
 701         g_return_val_if_fail (self != NULL, 0);
 702         return GEE_ABSTRACT_MAP_GET_CLASS (self)->get_size (self);
 703 }
 704
 705
 706 gboolean gee_abstract_map_get_read_only (GeeAbstractMap* self) {
 707         g_return_val_if_fail (self != NULL, FALSE);
 708         return GEE_ABSTRACT_MAP_GET_CLASS (self)->get_read_only (self);
 709 }
 710
 711
 712 GeeSet* gee_abstract_map_get_keys (GeeAbstractMap* self) {
 713         g_return_val_if_fail (self != NULL, NULL);
 714         return GEE_ABSTRACT_MAP_GET_CLASS (self)->get_keys (self);
 715 }
 716
 717
 718 GeeCollection* gee_abstract_map_get_values (GeeAbstractMap* self) {
 719         g_return_val_if_fail (self != NULL, NULL);
 720         return GEE_ABSTRACT_MAP_GET_CLASS (self)->get_values (self);
 721 }
 722
 723
 724 GeeSet* gee_abstract_map_get_entries (GeeAbstractMap* self) {
 725         g_return_val_if_fail (self != NULL, NULL);
 726         return GEE_ABSTRACT_MAP_GET_CLASS (self)->get_entries (self);
 727 }
 728
 729
 730 GeeMap* gee_abstract_map_get_read_only_view (GeeAbstractMap* self) {
 731         g_return_val_if_fail (self != NULL, NULL);
 732         return GEE_ABSTRACT_MAP_GET_CLASS (self)->get_read_only_view (self);
 733 }
 734
 735
 736 static gpointer _g_object_ref0 (gpointer self) {
 737         return self ? g_object_ref (self) : NULL;
 738 }
 739
 740
 741 static GeeMap* gee_abstract_map_real_get_read_only_view (GeeAbstractMap* base) {
 742         GeeMap* result;
 743         GeeAbstractMap* self;
 744         GeeMap* _tmp0_;
 745         GeeMap* _tmp1_;
 746         GeeMap* instance;
 747         GeeMap* _tmp2_;
 748         self = base;
 749         _tmp0_ = self->priv->_read_only_view;
 750         _tmp1_ = _g_object_ref0 (_tmp0_);
 751         instance = _tmp1_;
 752         _tmp2_ = self->priv->_read_only_view;
 753         if (_tmp2_ == NULL) {
 754                 GeeReadOnlyMap* _tmp3_;
 755                 GeeMap* _tmp4_;
 756                 GeeMap* _tmp5_;
 757                 _tmp3_ = gee_read_only_map_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, (GeeMap*) self);
 758                 _g_object_unref0 (instance);
 759                 instance = (GeeMap*) _tmp3_;
 760                 _tmp4_ = instance;
 761                 self->priv->_read_only_view = _tmp4_;
 762                 _tmp5_ = instance;
 763                 g_object_add_weak_pointer ((GObject*) _tmp5_, (void**) (&self->priv->_read_only_view));
 764         }
 765         result = instance;
 766         return result;
 767 }
 768
 769
 770 static void gee_abstract_map_class_init (GeeAbstractMapClass * klass) {
 771         gee_abstract_map_parent_class = g_type_class_peek_parent (klass);
 772         g_type_class_add_private (klass, sizeof (GeeAbstractMapPrivate));
 773         GEE_ABSTRACT_MAP_CLASS (klass)->has_key = gee_abstract_map_real_has_key;
 774         GEE_ABSTRACT_MAP_CLASS (klass)->has = gee_abstract_map_real_has;
 775         GEE_ABSTRACT_MAP_CLASS (klass)->get = gee_abstract_map_real_get;
 776         GEE_ABSTRACT_MAP_CLASS (klass)->set = gee_abstract_map_real_set;
 777         GEE_ABSTRACT_MAP_CLASS (klass)->unset = gee_abstract_map_real_unset;
 778         GEE_ABSTRACT_MAP_CLASS (klass)->map_iterator = gee_abstract_map_real_map_iterator;
 779         GEE_ABSTRACT_MAP_CLASS (klass)->clear = gee_abstract_map_real_clear;
 780         GEE_ABSTRACT_MAP_CLASS (klass)->foreach = gee_abstract_map_real_foreach;
 781         GEE_ABSTRACT_MAP_CLASS (klass)->stream = gee_abstract_map_real_stream;
 782         GEE_ABSTRACT_MAP_CLASS (klass)->reserved0 = gee_abstract_map_real_reserved0;
 783         GEE_ABSTRACT_MAP_CLASS (klass)->reserved1 = gee_abstract_map_real_reserved1;
 784         GEE_ABSTRACT_MAP_CLASS (klass)->reserved2 = gee_abstract_map_real_reserved2;
 785         GEE_ABSTRACT_MAP_CLASS (klass)->reserved3 = gee_abstract_map_real_reserved3;
 786         GEE_ABSTRACT_MAP_CLASS (klass)->reserved4 = gee_abstract_map_real_reserved4;
 787         GEE_ABSTRACT_MAP_CLASS (klass)->reserved5 = gee_abstract_map_real_reserved5;
 788         GEE_ABSTRACT_MAP_CLASS (klass)->reserved6 = gee_abstract_map_real_reserved6;
 789         GEE_ABSTRACT_MAP_CLASS (klass)->reserved7 = gee_abstract_map_real_reserved7;
 790         GEE_ABSTRACT_MAP_CLASS (klass)->reserved8 = gee_abstract_map_real_reserved8;
 791         GEE_ABSTRACT_MAP_CLASS (klass)->reserved9 = gee_abstract_map_real_reserved9;
 792         GEE_ABSTRACT_MAP_CLASS (klass)->get_read_only_view = gee_abstract_map_real_get_read_only_view;
 793         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_map_get_property;
 794         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_map_set_property;
 795         G_OBJECT_CLASS (klass)->finalize = gee_abstract_map_finalize;
 796         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 797         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 798         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 799         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 800         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 801         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 802         /**
 803          * {@inheritDoc}
 804          */
 805         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 806         /**
 807          * {@inheritDoc}
 808          */
 809         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MAP_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 810         /**
 811          * {@inheritDoc}
 812          */
 813         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 814         /**
 815          * {@inheritDoc}
 816          */
 817         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 818         /**
 819          * {@inheritDoc}
 820          */
 821         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_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));
 822         /**
 823          * {@inheritDoc}
 824          */
 825         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MAP_READ_ONLY_VIEW, g_param_spec_object ("read-only-view", "read-only-view", "read-only-view", GEE_TYPE_MAP, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 826 }
 827
 828
 829 static GType gee_abstract_map_gee_traversable_get_g_type (GeeAbstractMap* self) {
 830         return GEE_MAP_TYPE_ENTRY;
 831 }
 832
 833
 834 static GBoxedCopyFunc gee_abstract_map_gee_traversable_get_g_dup_func (GeeAbstractMap* self) {
 835         return g_object_ref;
 836 }
 837
 838
 839 static GDestroyNotify gee_abstract_map_gee_traversable_get_g_destroy_func (GeeAbstractMap* self) {
 840         return g_object_unref;
 841 }
 842
 843
 844 static void gee_abstract_map_gee_traversable_interface_init (GeeTraversableIface * iface) {
 845         gee_abstract_map_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
 846         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_abstract_map_foreach;
 847         iface->stream = (GeeIterator* (*)(GeeTraversable*, GType, GBoxedCopyFunc, GDestroyNotify, GeeStreamFunc, void*, GDestroyNotify)) gee_abstract_map_stream;
 848         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_abstract_map_gee_traversable_get_g_type;
 849         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_abstract_map_gee_traversable_get_g_dup_func;
 850         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_abstract_map_gee_traversable_get_g_destroy_func;
 851 }
 852
 853
 854 static GType gee_abstract_map_gee_iterable_get_g_type (GeeAbstractMap* self) {
 855         return GEE_MAP_TYPE_ENTRY;
 856 }
 857
 858
 859 static GBoxedCopyFunc gee_abstract_map_gee_iterable_get_g_dup_func (GeeAbstractMap* self) {
 860         return g_object_ref;
 861 }
 862
 863
 864 static GDestroyNotify gee_abstract_map_gee_iterable_get_g_destroy_func (GeeAbstractMap* self) {
 865         return g_object_unref;
 866 }
 867
 868
 869 static void gee_abstract_map_gee_iterable_interface_init (GeeIterableIface * iface) {
 870         gee_abstract_map_gee_iterable_parent_iface = g_type_interface_peek_parent (iface);
 871         iface->iterator = (GeeIterator* (*)(GeeIterable*)) gee_abstract_map_real_iterator;
 872         iface->get_g_type = (GType(*)(GeeIterable*)) gee_abstract_map_gee_iterable_get_g_type;
 873         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeIterable*)) gee_abstract_map_gee_iterable_get_g_dup_func;
 874         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeIterable*)) gee_abstract_map_gee_iterable_get_g_destroy_func;
 875 }
 876
 877
 878 static GType gee_abstract_map_gee_map_get_k_type (GeeAbstractMap* self) {
 879         return self->priv->k_type;
 880 }
 881
 882
 883 static GBoxedCopyFunc gee_abstract_map_gee_map_get_k_dup_func (GeeAbstractMap* self) {
 884         return self->priv->k_dup_func;
 885 }
 886
 887
 888 static GDestroyNotify gee_abstract_map_gee_map_get_k_destroy_func (GeeAbstractMap* self) {
 889         return self->priv->k_destroy_func;
 890 }
 891
 892
 893 static GType gee_abstract_map_gee_map_get_v_type (GeeAbstractMap* self) {
 894         return self->priv->v_type;
 895 }
 896
 897
 898 static GBoxedCopyFunc gee_abstract_map_gee_map_get_v_dup_func (GeeAbstractMap* self) {
 899         return self->priv->v_dup_func;
 900 }
 901
 902
 903 static GDestroyNotify gee_abstract_map_gee_map_get_v_destroy_func (GeeAbstractMap* self) {
 904         return self->priv->v_destroy_func;
 905 }
 906
 907
 908 static void gee_abstract_map_gee_map_interface_init (GeeMapIface * iface) {
 909         gee_abstract_map_gee_map_parent_iface = g_type_interface_peek_parent (iface);
 910         iface->has_key = (gboolean (*)(GeeMap*, gconstpointer)) gee_abstract_map_has_key;
 911         iface->has = (gboolean (*)(GeeMap*, gconstpointer, gconstpointer)) gee_abstract_map_has;
 912         iface->get = (gpointer (*)(GeeMap*, gconstpointer)) gee_abstract_map_get;
 913         iface->set = (void (*)(GeeMap*, gconstpointer, gconstpointer)) gee_abstract_map_set;
 914         iface->unset = (gboolean (*)(GeeMap*, gconstpointer, gpointer*)) gee_abstract_map_unset;
 915         iface->map_iterator = (GeeMapIterator* (*)(GeeMap*)) gee_abstract_map_map_iterator;
 916         iface->clear = (void (*)(GeeMap*)) gee_abstract_map_clear;
 917         iface->get_k_type = (GType(*)(GeeMap*)) gee_abstract_map_gee_map_get_k_type;
 918         iface->get_k_dup_func = (GBoxedCopyFunc(*)(GeeMap*)) gee_abstract_map_gee_map_get_k_dup_func;
 919         iface->get_k_destroy_func = (GDestroyNotify(*)(GeeMap*)) gee_abstract_map_gee_map_get_k_destroy_func;
 920         iface->get_v_type = (GType(*)(GeeMap*)) gee_abstract_map_gee_map_get_v_type;
 921         iface->get_v_dup_func = (GBoxedCopyFunc(*)(GeeMap*)) gee_abstract_map_gee_map_get_v_dup_func;
 922         iface->get_v_destroy_func = (GDestroyNotify(*)(GeeMap*)) gee_abstract_map_gee_map_get_v_destroy_func;
 923         iface->get_size = (gint (*) (GeeMap *)) gee_abstract_map_get_size;
 924         iface->get_read_only = (gboolean (*) (GeeMap *)) gee_abstract_map_get_read_only;
 925         iface->get_keys = (GeeSet* (*) (GeeMap *)) gee_abstract_map_get_keys;
 926         iface->get_values = (GeeCollection* (*) (GeeMap *)) gee_abstract_map_get_values;
 927         iface->get_entries = (GeeSet* (*) (GeeMap *)) gee_abstract_map_get_entries;
 928         iface->get_read_only_view = (GeeMap* (*) (GeeMap *)) gee_abstract_map_get_read_only_view;
 929 }
 930
 931
 932 static void gee_abstract_map_instance_init (GeeAbstractMap * self) {
 933         self->priv = GEE_ABSTRACT_MAP_GET_PRIVATE (self);
 934 }
 935
 936
 937 static void gee_abstract_map_finalize (GObject* obj) {
 938         GeeAbstractMap * self;
 939         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_ABSTRACT_MAP, GeeAbstractMap);
 940         G_OBJECT_CLASS (gee_abstract_map_parent_class)->finalize (obj);
 941 }
 942
 943
 944 /**
 945  * Skeletal implementation of the {@link Map} interface.
 946  *
 947  * Contains common code shared by all map implementations.
 948  *
 949  * @see HashMap
 950  * @see TreeMap
 951  */
 952 GType gee_abstract_map_get_type (void) {
 953         static volatile gsize gee_abstract_map_type_id__volatile = 0;
 954         if (g_once_init_enter (&gee_abstract_map_type_id__volatile)) {
 955                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMapClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_map_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMap), 0, (GInstanceInitFunc) gee_abstract_map_instance_init, NULL };
 956                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_abstract_map_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 957                 static const GInterfaceInfo gee_iterable_info = { (GInterfaceInitFunc) gee_abstract_map_gee_iterable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 958                 static const GInterfaceInfo gee_map_info = { (GInterfaceInitFunc) gee_abstract_map_gee_map_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 959                 GType gee_abstract_map_type_id;
 960                 gee_abstract_map_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeAbstractMap", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
 961                 g_type_add_interface_static (gee_abstract_map_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
 962                 g_type_add_interface_static (gee_abstract_map_type_id, GEE_TYPE_ITERABLE, &gee_iterable_info);
 963                 g_type_add_interface_static (gee_abstract_map_type_id, GEE_TYPE_MAP, &gee_map_info);
 964                 g_once_init_leave (&gee_abstract_map_type_id__volatile, gee_abstract_map_type_id);
 965         }
 966         return gee_abstract_map_type_id__volatile;
 967 }
 968
 969
 970 static void _vala_gee_abstract_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 971         GeeAbstractMap * self;
 972         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_ABSTRACT_MAP, GeeAbstractMap);
 973         switch (property_id) {
 974                 case GEE_ABSTRACT_MAP_READ_ONLY_VIEW:
 975                 g_value_take_object (value, gee_abstract_map_get_read_only_view (self));
 976                 break;
 977                 default:
 978                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 979                 break;
 980         }
 981 }
 982
 983
 984 static void _vala_gee_abstract_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 985         GeeAbstractMap * self;
 986         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_ABSTRACT_MAP, GeeAbstractMap);
 987         switch (property_id) {
 988                 case GEE_ABSTRACT_MAP_K_TYPE:
 989                 self->priv->k_type = g_value_get_gtype (value);
 990                 break;
 991                 case GEE_ABSTRACT_MAP_K_DUP_FUNC:
 992                 self->priv->k_dup_func = g_value_get_pointer (value);
 993                 break;
 994                 case GEE_ABSTRACT_MAP_K_DESTROY_FUNC:
 995                 self->priv->k_destroy_func = g_value_get_pointer (value);
 996                 break;
 997                 case GEE_ABSTRACT_MAP_V_TYPE:
 998                 self->priv->v_type = g_value_get_gtype (value);
 999                 break;
1000                 case GEE_ABSTRACT_MAP_V_DUP_FUNC:
1001                 self->priv->v_dup_func = g_value_get_pointer (value);
1002                 break;
1003                 case GEE_ABSTRACT_MAP_V_DESTROY_FUNC:
1004                 self->priv->v_destroy_func = g_value_get_pointer (value);
1005                 break;
1006                 default:
1007                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1008                 break;
1009         }
1010 }
1011
1012
1013