gee/readonlymap.c

   1 /* readonlymap.c generated by valac 0.18.0, the Vala compiler
   2  * generated from readonlymap.vala, do not modify */
   3
   4 /* readonlymap.vala
   5  *
   6  * Copyright (C) 2007-2008  Jürg Billeter
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  21  *
  22  * Author:
  23  *      Jürg Billeter <j@bitron.ch>
  24  */
  25
  26 #include <glib.h>
  27 #include <glib-object.h>
  28
  29
  30 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  31 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  32 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  33 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  34
  35 typedef struct _GeeTraversable GeeTraversable;
  36 typedef struct _GeeTraversableIface GeeTraversableIface;
  37
  38 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  39
  40 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  41 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  42 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  43 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  44 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  45 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  46
  47 typedef struct _GeeLazy GeeLazy;
  48 typedef struct _GeeLazyClass GeeLazyClass;
  49
  50 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  51 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  52 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  53 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  54
  55 typedef struct _GeeIterator GeeIterator;
  56 typedef struct _GeeIteratorIface GeeIteratorIface;
  57
  58 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  59 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  60 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  61 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  62
  63 typedef struct _GeeIterable GeeIterable;
  64 typedef struct _GeeIterableIface GeeIterableIface;
  65
  66 #define GEE_TYPE_MAP (gee_map_get_type ())
  67 #define GEE_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP, GeeMap))
  68 #define GEE_IS_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP))
  69 #define GEE_MAP_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP, GeeMapIface))
  70
  71 typedef struct _GeeMap GeeMap;
  72 typedef struct _GeeMapIface GeeMapIface;
  73
  74 #define GEE_TYPE_MAP_ITERATOR (gee_map_iterator_get_type ())
  75 #define GEE_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIterator))
  76 #define GEE_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP_ITERATOR))
  77 #define GEE_MAP_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIteratorIface))
  78
  79 typedef struct _GeeMapIterator GeeMapIterator;
  80 typedef struct _GeeMapIteratorIface GeeMapIteratorIface;
  81
  82 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  83 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  84 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  85 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  86
  87 typedef struct _GeeCollection GeeCollection;
  88 typedef struct _GeeCollectionIface GeeCollectionIface;
  89
  90 #define GEE_TYPE_SET (gee_set_get_type ())
  91 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
  92 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
  93 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
  94
  95 typedef struct _GeeSet GeeSet;
  96 typedef struct _GeeSetIface GeeSetIface;
  97
  98 #define GEE_MAP_TYPE_ENTRY (gee_map_entry_get_type ())
  99 #define GEE_MAP_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntry))
 100 #define GEE_MAP_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 101 #define GEE_MAP_IS_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_MAP_TYPE_ENTRY))
 102 #define GEE_MAP_IS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_MAP_TYPE_ENTRY))
 103 #define GEE_MAP_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 104
 105 typedef struct _GeeMapEntry GeeMapEntry;
 106 typedef struct _GeeMapEntryClass GeeMapEntryClass;
 107
 108 #define GEE_TYPE_READ_ONLY_MAP (gee_read_only_map_get_type ())
 109 #define GEE_READ_ONLY_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMap))
 110 #define GEE_READ_ONLY_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMapClass))
 111 #define GEE_IS_READ_ONLY_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_MAP))
 112 #define GEE_IS_READ_ONLY_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_MAP))
 113 #define GEE_READ_ONLY_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMapClass))
 114
 115 typedef struct _GeeReadOnlyMap GeeReadOnlyMap;
 116 typedef struct _GeeReadOnlyMapClass GeeReadOnlyMapClass;
 117 typedef struct _GeeReadOnlyMapPrivate GeeReadOnlyMapPrivate;
 118 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 119
 120 #define GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR (gee_read_only_map_map_iterator_get_type ())
 121 #define GEE_READ_ONLY_MAP_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, GeeReadOnlyMapMapIterator))
 122 #define GEE_READ_ONLY_MAP_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, GeeReadOnlyMapMapIteratorClass))
 123 #define GEE_READ_ONLY_MAP_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR))
 124 #define GEE_READ_ONLY_MAP_IS_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR))
 125 #define GEE_READ_ONLY_MAP_MAP_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, GeeReadOnlyMapMapIteratorClass))
 126
 127 typedef struct _GeeReadOnlyMapMapIterator GeeReadOnlyMapMapIterator;
 128 typedef struct _GeeReadOnlyMapMapIteratorClass GeeReadOnlyMapMapIteratorClass;
 129 typedef struct _GeeReadOnlyMapMapIteratorPrivate GeeReadOnlyMapMapIteratorPrivate;
 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 _GeeReadOnlyMap {
 254         GObject parent_instance;
 255         GeeReadOnlyMapPrivate * priv;
 256         GeeMap* _map;
 257 };
 258
 259 struct _GeeReadOnlyMapClass {
 260         GObjectClass parent_class;
 261         GeeMap* (*get_read_only_view) (GeeReadOnlyMap* self);
 262 };
 263
 264 struct _GeeReadOnlyMapPrivate {
 265         GType k_type;
 266         GBoxedCopyFunc k_dup_func;
 267         GDestroyNotify k_destroy_func;
 268         GType v_type;
 269         GBoxedCopyFunc v_dup_func;
 270         GDestroyNotify v_destroy_func;
 271 };
 272
 273 struct _GeeReadOnlyMapMapIterator {
 274         GObject parent_instance;
 275         GeeReadOnlyMapMapIteratorPrivate * priv;
 276         GeeMapIterator* _iter;
 277 };
 278
 279 struct _GeeReadOnlyMapMapIteratorClass {
 280         GObjectClass parent_class;
 281 };
 282
 283 struct _GeeReadOnlyMapMapIteratorPrivate {
 284         GType k_type;
 285         GBoxedCopyFunc k_dup_func;
 286         GDestroyNotify k_destroy_func;
 287         GType v_type;
 288         GBoxedCopyFunc v_dup_func;
 289         GDestroyNotify v_destroy_func;
 290 };
 291
 292
 293 static gpointer gee_read_only_map_parent_class = NULL;
 294 static gpointer gee_read_only_map_map_iterator_parent_class = NULL;
 295 static GeeMapIteratorIface* gee_read_only_map_map_iterator_gee_map_iterator_parent_iface = NULL;
 296 static GeeTraversableIface* gee_read_only_map_gee_traversable_parent_iface = NULL;
 297 static GeeIterableIface* gee_read_only_map_gee_iterable_parent_iface = NULL;
 298 static GeeMapIface* gee_read_only_map_gee_map_parent_iface = NULL;
 299
 300 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 301 gpointer gee_lazy_ref (gpointer instance);
 302 void gee_lazy_unref (gpointer instance);
 303 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 304 void gee_value_set_lazy (GValue* value, gpointer v_object);
 305 void gee_value_take_lazy (GValue* value, gpointer v_object);
 306 gpointer gee_value_get_lazy (const GValue* value);
 307 GType gee_lazy_get_type (void) G_GNUC_CONST;
 308 GType gee_iterator_get_type (void) G_GNUC_CONST;
 309 GType gee_traversable_get_type (void) G_GNUC_CONST;
 310 GType gee_iterable_get_type (void) G_GNUC_CONST;
 311 GType gee_map_iterator_get_type (void) G_GNUC_CONST;
 312 GType gee_collection_get_type (void) G_GNUC_CONST;
 313 GType gee_set_get_type (void) G_GNUC_CONST;
 314 GType gee_map_entry_get_type (void) G_GNUC_CONST;
 315 GType gee_map_get_type (void) G_GNUC_CONST;
 316 GType gee_read_only_map_get_type (void) G_GNUC_CONST;
 317 #define GEE_READ_ONLY_MAP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMapPrivate))
 318 enum  {
 319         GEE_READ_ONLY_MAP_DUMMY_PROPERTY,
 320         GEE_READ_ONLY_MAP_K_TYPE,
 321         GEE_READ_ONLY_MAP_K_DUP_FUNC,
 322         GEE_READ_ONLY_MAP_K_DESTROY_FUNC,
 323         GEE_READ_ONLY_MAP_V_TYPE,
 324         GEE_READ_ONLY_MAP_V_DUP_FUNC,
 325         GEE_READ_ONLY_MAP_V_DESTROY_FUNC,
 326         GEE_READ_ONLY_MAP_SIZE,
 327         GEE_READ_ONLY_MAP_READ_ONLY,
 328         GEE_READ_ONLY_MAP_KEYS,
 329         GEE_READ_ONLY_MAP_VALUES,
 330         GEE_READ_ONLY_MAP_ENTRIES,
 331         GEE_READ_ONLY_MAP_READ_ONLY_VIEW,
 332         GEE_READ_ONLY_MAP_KEY_TYPE,
 333         GEE_READ_ONLY_MAP_VALUE_TYPE
 334 };
 335 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);
 336 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);
 337 static gboolean gee_read_only_map_real_has_key (GeeMap* base, gconstpointer key);
 338 gboolean gee_map_has_key (GeeMap* self, gconstpointer key);
 339 gboolean gee_read_only_map_contains (GeeReadOnlyMap* self, gconstpointer key);
 340 static gboolean gee_read_only_map_real_has (GeeMap* base, gconstpointer key, gconstpointer value);
 341 gboolean gee_map_has (GeeMap* self, gconstpointer key, gconstpointer value);
 342 static gpointer gee_read_only_map_real_get (GeeMap* base, gconstpointer key);
 343 gpointer gee_map_get (GeeMap* self, gconstpointer key);
 344 static void gee_read_only_map_real_set (GeeMap* base, gconstpointer key, gconstpointer value);
 345 static gboolean gee_read_only_map_real_unset (GeeMap* base, gconstpointer key, gpointer* value);
 346 gboolean gee_read_only_map_remove (GeeReadOnlyMap* self, gconstpointer key, gpointer* value);
 347 static void gee_read_only_map_real_clear (GeeMap* base);
 348 static GeeMapIterator* gee_read_only_map_real_map_iterator (GeeMap* base);
 349 GeeMapIterator* gee_map_map_iterator (GeeMap* self);
 350 GeeReadOnlyMapMapIterator* gee_read_only_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, GeeMapIterator* iterator);
 351 GeeReadOnlyMapMapIterator* gee_read_only_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, GeeMapIterator* iterator);
 352 GType gee_read_only_map_map_iterator_get_type (void) G_GNUC_CONST;
 353 static void gee_read_only_map_real_set_all (GeeMap* base, GeeMap* map);
 354 static gboolean gee_read_only_map_real_unset_all (GeeMap* base, GeeMap* map);
 355 gboolean gee_read_only_map_remove_all (GeeReadOnlyMap* self, GeeMap* map);
 356 static gboolean gee_read_only_map_real_has_all (GeeMap* base, GeeMap* map);
 357 gboolean gee_map_has_all (GeeMap* self, GeeMap* map);
 358 gboolean gee_read_only_map_contains_all (GeeReadOnlyMap* self, GeeMap* map);
 359 static GeeIterator* gee_read_only_map_real_iterator (GeeIterable* base);
 360 GeeSet* gee_map_get_entries (GeeMap* self);
 361 GeeIterator* gee_iterable_iterator (GeeIterable* self);
 362 static gboolean gee_read_only_map_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 363 gboolean gee_traversable_foreach (GeeTraversable* self, GeeForallFunc f, void* f_target);
 364 static GeeIterator* gee_read_only_map_real_stream (GeeTraversable* base, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 365 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);
 366 static GeeIterator* gee_read_only_map_real_filter (GeeTraversable* base, GeePredicate f, void* f_target, GDestroyNotify f_target_destroy_notify);
 367 GeeIterator* gee_traversable_filter (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 368 static GeeIterator* gee_read_only_map_real_chop (GeeTraversable* base, gint offset, gint length);
 369 GeeIterator* gee_traversable_chop (GeeTraversable* self, gint offset, gint length);
 370 gint gee_map_get_size (GeeMap* self);
 371 gboolean gee_map_get_is_empty (GeeMap* self);
 372 GeeSet* gee_map_get_keys (GeeMap* self);
 373 GeeCollection* gee_map_get_values (GeeMap* self);
 374 GeeMap* gee_read_only_map_get_read_only_view (GeeReadOnlyMap* self);
 375 GType gee_read_only_map_get_key_type (GeeReadOnlyMap* self);
 376 GType gee_read_only_map_get_value_type (GeeReadOnlyMap* self);
 377 #define GEE_READ_ONLY_MAP_MAP_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, GeeReadOnlyMapMapIteratorPrivate))
 378 enum  {
 379         GEE_READ_ONLY_MAP_MAP_ITERATOR_DUMMY_PROPERTY,
 380         GEE_READ_ONLY_MAP_MAP_ITERATOR_K_TYPE,
 381         GEE_READ_ONLY_MAP_MAP_ITERATOR_K_DUP_FUNC,
 382         GEE_READ_ONLY_MAP_MAP_ITERATOR_K_DESTROY_FUNC,
 383         GEE_READ_ONLY_MAP_MAP_ITERATOR_V_TYPE,
 384         GEE_READ_ONLY_MAP_MAP_ITERATOR_V_DUP_FUNC,
 385         GEE_READ_ONLY_MAP_MAP_ITERATOR_V_DESTROY_FUNC,
 386         GEE_READ_ONLY_MAP_MAP_ITERATOR_READ_ONLY,
 387         GEE_READ_ONLY_MAP_MAP_ITERATOR_MUTABLE,
 388         GEE_READ_ONLY_MAP_MAP_ITERATOR_VALID
 389 };
 390 static gboolean gee_read_only_map_map_iterator_real_next (GeeMapIterator* base);
 391 gboolean gee_map_iterator_next (GeeMapIterator* self);
 392 static gboolean gee_read_only_map_map_iterator_real_has_next (GeeMapIterator* base);
 393 gboolean gee_map_iterator_has_next (GeeMapIterator* self);
 394 static gpointer gee_read_only_map_map_iterator_real_get_key (GeeMapIterator* base);
 395 gpointer gee_map_iterator_get_key (GeeMapIterator* self);
 396 static gpointer gee_read_only_map_map_iterator_real_get_value (GeeMapIterator* base);
 397 gpointer gee_map_iterator_get_value (GeeMapIterator* self);
 398 static void gee_read_only_map_map_iterator_real_set_value (GeeMapIterator* base, gconstpointer value);
 399 static void gee_read_only_map_map_iterator_real_unset (GeeMapIterator* base);
 400 gboolean gee_map_iterator_get_valid (GeeMapIterator* self);
 401 static void gee_read_only_map_map_iterator_finalize (GObject* obj);
 402 gboolean gee_map_iterator_get_read_only (GeeMapIterator* self);
 403 gboolean gee_map_iterator_get_mutable (GeeMapIterator* self);
 404 static void _vala_gee_read_only_map_map_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 405 static void _vala_gee_read_only_map_map_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 406 static void gee_read_only_map_finalize (GObject* obj);
 407 gboolean gee_map_get_read_only (GeeMap* self);
 408 static void _vala_gee_read_only_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 409 static void _vala_gee_read_only_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 410
 411
 412 /**
 413  * Constructs a read-only map that mirrors the content of the specified map.
 414  *
 415  * @param map the map to decorate.
 416  */
 417 static gpointer _g_object_ref0 (gpointer self) {
 418         return self ? g_object_ref (self) : NULL;
 419 }
 420
 421
 422 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) {
 423         GeeReadOnlyMap * self = NULL;
 424         GeeMap* _tmp0_;
 425         GeeMap* _tmp1_;
 426         g_return_val_if_fail (map != NULL, NULL);
 427         self = (GeeReadOnlyMap*) g_object_new (object_type, NULL);
 428         self->priv->k_type = k_type;
 429         self->priv->k_dup_func = k_dup_func;
 430         self->priv->k_destroy_func = k_destroy_func;
 431         self->priv->v_type = v_type;
 432         self->priv->v_dup_func = v_dup_func;
 433         self->priv->v_destroy_func = v_destroy_func;
 434         _tmp0_ = map;
 435         _tmp1_ = _g_object_ref0 (_tmp0_);
 436         _g_object_unref0 (self->_map);
 437         self->_map = _tmp1_;
 438         return self;
 439 }
 440
 441
 442 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) {
 443         return gee_read_only_map_construct (GEE_TYPE_READ_ONLY_MAP, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, map);
 444 }
 445
 446
 447 /**
 448  * {@inheritDoc}
 449  */
 450 static gboolean gee_read_only_map_real_has_key (GeeMap* base, gconstpointer key) {
 451         GeeReadOnlyMap * self;
 452         gboolean result = FALSE;
 453         GeeMap* _tmp0_;
 454         gconstpointer _tmp1_;
 455         gboolean _tmp2_ = FALSE;
 456         self = (GeeReadOnlyMap*) base;
 457         _tmp0_ = self->_map;
 458         _tmp1_ = key;
 459         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
 460         result = _tmp2_;
 461         return result;
 462 }
 463
 464
 465 /**
 466  * {@inheritDoc}
 467  */
 468 gboolean gee_read_only_map_contains (GeeReadOnlyMap* self, gconstpointer key) {
 469         gboolean result = FALSE;
 470         GeeMap* _tmp0_;
 471         gconstpointer _tmp1_;
 472         gboolean _tmp2_ = FALSE;
 473         g_return_val_if_fail (self != NULL, FALSE);
 474         _tmp0_ = self->_map;
 475         _tmp1_ = key;
 476         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
 477         result = _tmp2_;
 478         return result;
 479 }
 480
 481
 482 /**
 483  * {@inheritDoc}
 484  */
 485 static gboolean gee_read_only_map_real_has (GeeMap* base, gconstpointer key, gconstpointer value) {
 486         GeeReadOnlyMap * self;
 487         gboolean result = FALSE;
 488         GeeMap* _tmp0_;
 489         gconstpointer _tmp1_;
 490         gconstpointer _tmp2_;
 491         gboolean _tmp3_ = FALSE;
 492         self = (GeeReadOnlyMap*) base;
 493         _tmp0_ = self->_map;
 494         _tmp1_ = key;
 495         _tmp2_ = value;
 496         _tmp3_ = gee_map_has (_tmp0_, _tmp1_, _tmp2_);
 497         result = _tmp3_;
 498         return result;
 499 }
 500
 501
 502 /**
 503  * {@inheritDoc}
 504  */
 505 static gpointer gee_read_only_map_real_get (GeeMap* base, gconstpointer key) {
 506         GeeReadOnlyMap * self;
 507         gpointer result = NULL;
 508         GeeMap* _tmp0_;
 509         gconstpointer _tmp1_;
 510         gpointer _tmp2_ = NULL;
 511         self = (GeeReadOnlyMap*) base;
 512         _tmp0_ = self->_map;
 513         _tmp1_ = key;
 514         _tmp2_ = gee_map_get (_tmp0_, _tmp1_);
 515         result = _tmp2_;
 516         return result;
 517 }
 518
 519
 520 /**
 521  * Unimplemented method (read only map).
 522  */
 523 static void gee_read_only_map_real_set (GeeMap* base, gconstpointer key, gconstpointer value) {
 524         GeeReadOnlyMap * self;
 525         self = (GeeReadOnlyMap*) base;
 526         g_assert_not_reached ();
 527 }
 528
 529
 530 /**
 531  * Unimplemented method (read only map).
 532  */
 533 static gboolean gee_read_only_map_real_unset (GeeMap* base, gconstpointer key, gpointer* value) {
 534         GeeReadOnlyMap * self;
 535         gpointer _vala_value = NULL;
 536         gboolean result = FALSE;
 537         self = (GeeReadOnlyMap*) base;
 538         g_assert_not_reached ();
 539         if (value) {
 540                 *value = _vala_value;
 541         } else {
 542                 ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
 543         }
 544         return result;
 545 }
 546
 547
 548 /**
 549  * Unimplemented method (read only map).
 550  */
 551 gboolean gee_read_only_map_remove (GeeReadOnlyMap* self, gconstpointer key, gpointer* value) {
 552         gpointer _vala_value = NULL;
 553         gboolean result = FALSE;
 554         g_return_val_if_fail (self != NULL, FALSE);
 555         g_assert_not_reached ();
 556         if (value) {
 557                 *value = _vala_value;
 558         } else {
 559                 ((_vala_value == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (_vala_value = (self->priv->v_destroy_func (_vala_value), NULL));
 560         }
 561         return result;
 562 }
 563
 564
 565 /**
 566  * Unimplemented method (read only map).
 567  */
 568 static void gee_read_only_map_real_clear (GeeMap* base) {
 569         GeeReadOnlyMap * self;
 570         self = (GeeReadOnlyMap*) base;
 571         g_assert_not_reached ();
 572 }
 573
 574
 575 /**
 576  * {@inheritDoc}
 577  */
 578 static GeeMapIterator* gee_read_only_map_real_map_iterator (GeeMap* base) {
 579         GeeReadOnlyMap * self;
 580         GeeMapIterator* result = NULL;
 581         GeeMap* _tmp0_;
 582         GeeMapIterator* _tmp1_ = NULL;
 583         GeeMapIterator* _tmp2_;
 584         GeeReadOnlyMapMapIterator* _tmp3_;
 585         GeeMapIterator* _tmp4_;
 586         self = (GeeReadOnlyMap*) base;
 587         _tmp0_ = self->_map;
 588         _tmp1_ = gee_map_map_iterator (_tmp0_);
 589         _tmp2_ = _tmp1_;
 590         _tmp3_ = gee_read_only_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, _tmp2_);
 591         _tmp4_ = (GeeMapIterator*) _tmp3_;
 592         _g_object_unref0 (_tmp2_);
 593         result = _tmp4_;
 594         return result;
 595 }
 596
 597
 598 /**
 599  * Unimplemented method (read only map).
 600  */
 601 static void gee_read_only_map_real_set_all (GeeMap* base, GeeMap* map) {
 602         GeeReadOnlyMap * self;
 603         self = (GeeReadOnlyMap*) base;
 604         g_return_if_fail (map != NULL);
 605         g_assert_not_reached ();
 606 }
 607
 608
 609 /**
 610  * Unimplemented method (read only map).
 611  */
 612 static gboolean gee_read_only_map_real_unset_all (GeeMap* base, GeeMap* map) {
 613         GeeReadOnlyMap * self;
 614         gboolean result = FALSE;
 615         self = (GeeReadOnlyMap*) base;
 616         g_return_val_if_fail (map != NULL, FALSE);
 617         g_assert_not_reached ();
 618         return result;
 619 }
 620
 621
 622 /**
 623  * Unimplemented method (read only map).
 624  */
 625 gboolean gee_read_only_map_remove_all (GeeReadOnlyMap* self, GeeMap* map) {
 626         gboolean result = FALSE;
 627         g_return_val_if_fail (self != NULL, FALSE);
 628         g_return_val_if_fail (map != NULL, FALSE);
 629         g_assert_not_reached ();
 630         return result;
 631 }
 632
 633
 634 /**
 635  * {@inheritDoc}
 636  */
 637 static gboolean gee_read_only_map_real_has_all (GeeMap* base, GeeMap* map) {
 638         GeeReadOnlyMap * self;
 639         gboolean result = FALSE;
 640         GeeMap* _tmp0_;
 641         GeeMap* _tmp1_;
 642         gboolean _tmp2_ = FALSE;
 643         self = (GeeReadOnlyMap*) base;
 644         g_return_val_if_fail (map != NULL, FALSE);
 645         _tmp0_ = self->_map;
 646         _tmp1_ = map;
 647         _tmp2_ = gee_map_has_all (_tmp0_, _tmp1_);
 648         result = _tmp2_;
 649         return result;
 650 }
 651
 652
 653 /**
 654  * {@inheritDoc}
 655  */
 656 gboolean gee_read_only_map_contains_all (GeeReadOnlyMap* self, GeeMap* map) {
 657         gboolean result = FALSE;
 658         GeeMap* _tmp0_;
 659         GeeMap* _tmp1_;
 660         gboolean _tmp2_ = FALSE;
 661         g_return_val_if_fail (self != NULL, FALSE);
 662         g_return_val_if_fail (map != NULL, FALSE);
 663         _tmp0_ = self->_map;
 664         _tmp1_ = map;
 665         _tmp2_ = gee_map_has_all (_tmp0_, _tmp1_);
 666         result = _tmp2_;
 667         return result;
 668 }
 669
 670
 671 /**
 672  * {@inheritDoc}
 673  */
 674 static GeeIterator* gee_read_only_map_real_iterator (GeeIterable* base) {
 675         GeeReadOnlyMap * self;
 676         GeeIterator* result = NULL;
 677         GeeSet* _tmp0_;
 678         GeeSet* _tmp1_;
 679         GeeSet* _tmp2_;
 680         GeeIterator* _tmp3_ = NULL;
 681         GeeIterator* _tmp4_;
 682         self = (GeeReadOnlyMap*) base;
 683         _tmp0_ = gee_map_get_entries ((GeeMap*) self);
 684         _tmp1_ = _tmp0_;
 685         _tmp2_ = _tmp1_;
 686         _tmp3_ = gee_iterable_iterator ((GeeIterable*) _tmp2_);
 687         _tmp4_ = _tmp3_;
 688         _g_object_unref0 (_tmp2_);
 689         result = _tmp4_;
 690         return result;
 691 }
 692
 693
 694 /**
 695  * {@inheritDoc}
 696  */
 697 static gboolean gee_read_only_map_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
 698         GeeReadOnlyMap * self;
 699         gboolean result = FALSE;
 700         GeeMap* _tmp0_;
 701         GeeForallFunc _tmp1_;
 702         void* _tmp1__target;
 703         gboolean _tmp2_ = FALSE;
 704         self = (GeeReadOnlyMap*) base;
 705         _tmp0_ = self->_map;
 706         _tmp1_ = f;
 707         _tmp1__target = f_target;
 708         _tmp2_ = gee_traversable_foreach ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target);
 709         result = _tmp2_;
 710         return result;
 711 }
 712
 713
 714 /**
 715  * {@inheritDoc}
 716  */
 717 static GeeIterator* gee_read_only_map_real_stream (GeeTraversable* base, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 718         GeeReadOnlyMap * self;
 719         GeeIterator* result = NULL;
 720         GeeMap* _tmp0_;
 721         GeeStreamFunc _tmp1_;
 722         void* _tmp1__target;
 723         GDestroyNotify _tmp1__target_destroy_notify;
 724         GeeIterator* _tmp2_ = NULL;
 725         self = (GeeReadOnlyMap*) base;
 726         _tmp0_ = self->_map;
 727         _tmp1_ = f;
 728         _tmp1__target = f_target;
 729         _tmp1__target_destroy_notify = f_target_destroy_notify;
 730         f_target_destroy_notify = NULL;
 731         _tmp2_ = gee_traversable_stream ((GeeTraversable*) _tmp0_, a_type, (GBoxedCopyFunc) a_dup_func, a_destroy_func, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
 732         result = _tmp2_;
 733         (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
 734         f = NULL;
 735         f_target = NULL;
 736         f_target_destroy_notify = NULL;
 737         return result;
 738 }
 739
 740
 741 static GeeIterator* gee_read_only_map_real_filter (GeeTraversable* base, GeePredicate f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 742         GeeReadOnlyMap * self;
 743         GeeIterator* result = NULL;
 744         GeeMap* _tmp0_;
 745         GeePredicate _tmp1_;
 746         void* _tmp1__target;
 747         GDestroyNotify _tmp1__target_destroy_notify;
 748         GeeIterator* _tmp2_ = NULL;
 749         self = (GeeReadOnlyMap*) base;
 750         _tmp0_ = self->_map;
 751         _tmp1_ = f;
 752         _tmp1__target = f_target;
 753         _tmp1__target_destroy_notify = f_target_destroy_notify;
 754         f_target_destroy_notify = NULL;
 755         _tmp2_ = gee_traversable_filter ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
 756         result = _tmp2_;
 757         (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
 758         f = NULL;
 759         f_target = NULL;
 760         f_target_destroy_notify = NULL;
 761         return result;
 762 }
 763
 764
 765 static GeeIterator* gee_read_only_map_real_chop (GeeTraversable* base, gint offset, gint length) {
 766         GeeReadOnlyMap * self;
 767         GeeIterator* result = NULL;
 768         GeeMap* _tmp0_;
 769         gint _tmp1_;
 770         gint _tmp2_;
 771         GeeIterator* _tmp3_ = NULL;
 772         self = (GeeReadOnlyMap*) base;
 773         _tmp0_ = self->_map;
 774         _tmp1_ = offset;
 775         _tmp2_ = length;
 776         _tmp3_ = gee_traversable_chop ((GeeTraversable*) _tmp0_, _tmp1_, _tmp2_);
 777         result = _tmp3_;
 778         return result;
 779 }
 780
 781
 782 static gint gee_read_only_map_real_get_size (GeeMap* base) {
 783         gint result;
 784         GeeReadOnlyMap* self;
 785         GeeMap* _tmp0_;
 786         gint _tmp1_;
 787         gint _tmp2_;
 788         self = (GeeReadOnlyMap*) base;
 789         _tmp0_ = self->_map;
 790         _tmp1_ = gee_map_get_size (_tmp0_);
 791         _tmp2_ = _tmp1_;
 792         result = _tmp2_;
 793         return result;
 794 }
 795
 796
 797 static gboolean gee_read_only_map_real_get_is_empty (GeeMap* base) {
 798         gboolean result;
 799         GeeReadOnlyMap* self;
 800         GeeMap* _tmp0_;
 801         gboolean _tmp1_;
 802         gboolean _tmp2_;
 803         self = (GeeReadOnlyMap*) base;
 804         _tmp0_ = self->_map;
 805         _tmp1_ = gee_map_get_is_empty (_tmp0_);
 806         _tmp2_ = _tmp1_;
 807         result = _tmp2_;
 808         return result;
 809 }
 810
 811
 812 static gboolean gee_read_only_map_real_get_read_only (GeeMap* base) {
 813         gboolean result;
 814         GeeReadOnlyMap* self;
 815         self = (GeeReadOnlyMap*) base;
 816         result = TRUE;
 817         return result;
 818 }
 819
 820
 821 static GeeSet* gee_read_only_map_real_get_keys (GeeMap* base) {
 822         GeeSet* result;
 823         GeeReadOnlyMap* self;
 824         GeeMap* _tmp0_;
 825         GeeSet* _tmp1_;
 826         GeeSet* _tmp2_;
 827         self = (GeeReadOnlyMap*) base;
 828         _tmp0_ = self->_map;
 829         _tmp1_ = gee_map_get_keys (_tmp0_);
 830         _tmp2_ = _tmp1_;
 831         result = _tmp2_;
 832         return result;
 833 }
 834
 835
 836 static GeeCollection* gee_read_only_map_real_get_values (GeeMap* base) {
 837         GeeCollection* result;
 838         GeeReadOnlyMap* self;
 839         GeeMap* _tmp0_;
 840         GeeCollection* _tmp1_;
 841         GeeCollection* _tmp2_;
 842         self = (GeeReadOnlyMap*) base;
 843         _tmp0_ = self->_map;
 844         _tmp1_ = gee_map_get_values (_tmp0_);
 845         _tmp2_ = _tmp1_;
 846         result = _tmp2_;
 847         return result;
 848 }
 849
 850
 851 static GeeSet* gee_read_only_map_real_get_entries (GeeMap* base) {
 852         GeeSet* result;
 853         GeeReadOnlyMap* self;
 854         GeeMap* _tmp0_;
 855         GeeSet* _tmp1_;
 856         GeeSet* _tmp2_;
 857         self = (GeeReadOnlyMap*) base;
 858         _tmp0_ = self->_map;
 859         _tmp1_ = gee_map_get_entries (_tmp0_);
 860         _tmp2_ = _tmp1_;
 861         result = _tmp2_;
 862         return result;
 863 }
 864
 865
 866 GeeMap* gee_read_only_map_get_read_only_view (GeeReadOnlyMap* self) {
 867         g_return_val_if_fail (self != NULL, NULL);
 868         return GEE_READ_ONLY_MAP_GET_CLASS (self)->get_read_only_view (self);
 869 }
 870
 871
 872 static GeeMap* gee_read_only_map_real_get_read_only_view (GeeReadOnlyMap* base) {
 873         GeeMap* result;
 874         GeeReadOnlyMap* self;
 875         GeeMap* _tmp0_;
 876         self = base;
 877         _tmp0_ = _g_object_ref0 ((GeeMap*) self);
 878         result = _tmp0_;
 879         return result;
 880 }
 881
 882
 883 GType gee_read_only_map_get_key_type (GeeReadOnlyMap* self) {
 884         GType result;
 885         g_return_val_if_fail (self != NULL, 0UL);
 886         result = self->priv->k_type;
 887         return result;
 888 }
 889
 890
 891 GType gee_read_only_map_get_value_type (GeeReadOnlyMap* self) {
 892         GType result;
 893         g_return_val_if_fail (self != NULL, 0UL);
 894         result = self->priv->v_type;
 895         return result;
 896 }
 897
 898
 899 static GType gee_read_only_map_real_get_element_type (GeeTraversable* base) {
 900         GType result;
 901         GeeReadOnlyMap* self;
 902         self = (GeeReadOnlyMap*) base;
 903         result = GEE_MAP_TYPE_ENTRY;
 904         return result;
 905 }
 906
 907
 908 GeeReadOnlyMapMapIterator* gee_read_only_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, GeeMapIterator* iterator) {
 909         GeeReadOnlyMapMapIterator * self = NULL;
 910         GeeMapIterator* _tmp0_;
 911         GeeMapIterator* _tmp1_;
 912         g_return_val_if_fail (iterator != NULL, NULL);
 913         self = (GeeReadOnlyMapMapIterator*) g_object_new (object_type, NULL);
 914         self->priv->k_type = k_type;
 915         self->priv->k_dup_func = k_dup_func;
 916         self->priv->k_destroy_func = k_destroy_func;
 917         self->priv->v_type = v_type;
 918         self->priv->v_dup_func = v_dup_func;
 919         self->priv->v_destroy_func = v_destroy_func;
 920         _tmp0_ = iterator;
 921         _tmp1_ = _g_object_ref0 (_tmp0_);
 922         _g_object_unref0 (self->_iter);
 923         self->_iter = _tmp1_;
 924         return self;
 925 }
 926
 927
 928 GeeReadOnlyMapMapIterator* gee_read_only_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, GeeMapIterator* iterator) {
 929         return gee_read_only_map_map_iterator_construct (GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, iterator);
 930 }
 931
 932
 933 static gboolean gee_read_only_map_map_iterator_real_next (GeeMapIterator* base) {
 934         GeeReadOnlyMapMapIterator * self;
 935         gboolean result = FALSE;
 936         GeeMapIterator* _tmp0_;
 937         gboolean _tmp1_ = FALSE;
 938         self = (GeeReadOnlyMapMapIterator*) base;
 939         _tmp0_ = self->_iter;
 940         _tmp1_ = gee_map_iterator_next (_tmp0_);
 941         result = _tmp1_;
 942         return result;
 943 }
 944
 945
 946 static gboolean gee_read_only_map_map_iterator_real_has_next (GeeMapIterator* base) {
 947         GeeReadOnlyMapMapIterator * self;
 948         gboolean result = FALSE;
 949         GeeMapIterator* _tmp0_;
 950         gboolean _tmp1_ = FALSE;
 951         self = (GeeReadOnlyMapMapIterator*) base;
 952         _tmp0_ = self->_iter;
 953         _tmp1_ = gee_map_iterator_has_next (_tmp0_);
 954         result = _tmp1_;
 955         return result;
 956 }
 957
 958
 959 static gpointer gee_read_only_map_map_iterator_real_get_key (GeeMapIterator* base) {
 960         GeeReadOnlyMapMapIterator * self;
 961         gpointer result = NULL;
 962         GeeMapIterator* _tmp0_;
 963         gpointer _tmp1_ = NULL;
 964         self = (GeeReadOnlyMapMapIterator*) base;
 965         _tmp0_ = self->_iter;
 966         _tmp1_ = gee_map_iterator_get_key (_tmp0_);
 967         result = _tmp1_;
 968         return result;
 969 }
 970
 971
 972 static gpointer gee_read_only_map_map_iterator_real_get_value (GeeMapIterator* base) {
 973         GeeReadOnlyMapMapIterator * self;
 974         gpointer result = NULL;
 975         GeeMapIterator* _tmp0_;
 976         gpointer _tmp1_ = NULL;
 977         self = (GeeReadOnlyMapMapIterator*) base;
 978         _tmp0_ = self->_iter;
 979         _tmp1_ = gee_map_iterator_get_value (_tmp0_);
 980         result = _tmp1_;
 981         return result;
 982 }
 983
 984
 985 static void gee_read_only_map_map_iterator_real_set_value (GeeMapIterator* base, gconstpointer value) {
 986         GeeReadOnlyMapMapIterator * self;
 987         self = (GeeReadOnlyMapMapIterator*) base;
 988         g_assert_not_reached ();
 989 }
 990
 991
 992 static void gee_read_only_map_map_iterator_real_unset (GeeMapIterator* base) {
 993         GeeReadOnlyMapMapIterator * self;
 994         self = (GeeReadOnlyMapMapIterator*) base;
 995         g_assert_not_reached ();
 996 }
 997
 998
 999 static gboolean gee_read_only_map_map_iterator_real_get_read_only (GeeMapIterator* base) {
1000         gboolean result;
1001         GeeReadOnlyMapMapIterator* self;
1002         self = (GeeReadOnlyMapMapIterator*) base;
1003         result = TRUE;
1004         return result;
1005 }
1006
1007
1008 static gboolean gee_read_only_map_map_iterator_real_get_mutable (GeeMapIterator* base) {
1009         gboolean result;
1010         GeeReadOnlyMapMapIterator* self;
1011         self = (GeeReadOnlyMapMapIterator*) base;
1012         result = FALSE;
1013         return result;
1014 }
1015
1016
1017 static gboolean gee_read_only_map_map_iterator_real_get_valid (GeeMapIterator* base) {
1018         gboolean result;
1019         GeeReadOnlyMapMapIterator* self;
1020         GeeMapIterator* _tmp0_;
1021         gboolean _tmp1_;
1022         gboolean _tmp2_;
1023         self = (GeeReadOnlyMapMapIterator*) base;
1024         _tmp0_ = self->_iter;
1025         _tmp1_ = gee_map_iterator_get_valid (_tmp0_);
1026         _tmp2_ = _tmp1_;
1027         result = _tmp2_;
1028         return result;
1029 }
1030
1031
1032 static void gee_read_only_map_map_iterator_class_init (GeeReadOnlyMapMapIteratorClass * klass) {
1033         gee_read_only_map_map_iterator_parent_class = g_type_class_peek_parent (klass);
1034         g_type_class_add_private (klass, sizeof (GeeReadOnlyMapMapIteratorPrivate));
1035         G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_map_map_iterator_get_property;
1036         G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_map_map_iterator_set_property;
1037         G_OBJECT_CLASS (klass)->finalize = gee_read_only_map_map_iterator_finalize;
1038         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1039         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1040         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1041         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1042         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1043         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1044         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_MAP_MAP_ITERATOR_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
1045         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_MAP_MAP_ITERATOR_MUTABLE, g_param_spec_boolean ("mutable", "mutable", "mutable", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
1046         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_MAP_MAP_ITERATOR_VALID, g_param_spec_boolean ("valid", "valid", "valid", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
1047 }
1048
1049
1050 static GType gee_read_only_map_map_iterator_gee_map_iterator_get_k_type (GeeReadOnlyMapMapIterator* self) {
1051         return self->priv->k_type;
1052 }
1053
1054
1055 static GBoxedCopyFunc gee_read_only_map_map_iterator_gee_map_iterator_get_k_dup_func (GeeReadOnlyMapMapIterator* self) {
1056         return self->priv->k_dup_func;
1057 }
1058
1059
1060 static GDestroyNotify gee_read_only_map_map_iterator_gee_map_iterator_get_k_destroy_func (GeeReadOnlyMapMapIterator* self) {
1061         return self->priv->k_destroy_func;
1062 }
1063
1064
1065 static GType gee_read_only_map_map_iterator_gee_map_iterator_get_v_type (GeeReadOnlyMapMapIterator* self) {
1066         return self->priv->v_type;
1067 }
1068
1069
1070 static GBoxedCopyFunc gee_read_only_map_map_iterator_gee_map_iterator_get_v_dup_func (GeeReadOnlyMapMapIterator* self) {
1071         return self->priv->v_dup_func;
1072 }
1073
1074
1075 static GDestroyNotify gee_read_only_map_map_iterator_gee_map_iterator_get_v_destroy_func (GeeReadOnlyMapMapIterator* self) {
1076         return self->priv->v_destroy_func;
1077 }
1078
1079
1080 static void gee_read_only_map_map_iterator_gee_map_iterator_interface_init (GeeMapIteratorIface * iface) {
1081         gee_read_only_map_map_iterator_gee_map_iterator_parent_iface = g_type_interface_peek_parent (iface);
1082         iface->next = (gboolean (*)(GeeMapIterator*)) gee_read_only_map_map_iterator_real_next;
1083         iface->has_next = (gboolean (*)(GeeMapIterator*)) gee_read_only_map_map_iterator_real_has_next;
1084         iface->get_key = (gpointer (*)(GeeMapIterator*)) gee_read_only_map_map_iterator_real_get_key;
1085         iface->get_value = (gpointer (*)(GeeMapIterator*)) gee_read_only_map_map_iterator_real_get_value;
1086         iface->set_value = (void (*)(GeeMapIterator*, gconstpointer)) gee_read_only_map_map_iterator_real_set_value;
1087         iface->unset = (void (*)(GeeMapIterator*)) gee_read_only_map_map_iterator_real_unset;
1088         iface->get_k_type = (GType(*)(GeeMapIterator*)) gee_read_only_map_map_iterator_gee_map_iterator_get_k_type;
1089         iface->get_k_dup_func = (GBoxedCopyFunc(*)(GeeMapIterator*)) gee_read_only_map_map_iterator_gee_map_iterator_get_k_dup_func;
1090         iface->get_k_destroy_func = (GDestroyNotify(*)(GeeMapIterator*)) gee_read_only_map_map_iterator_gee_map_iterator_get_k_destroy_func;
1091         iface->get_v_type = (GType(*)(GeeMapIterator*)) gee_read_only_map_map_iterator_gee_map_iterator_get_v_type;
1092         iface->get_v_dup_func = (GBoxedCopyFunc(*)(GeeMapIterator*)) gee_read_only_map_map_iterator_gee_map_iterator_get_v_dup_func;
1093         iface->get_v_destroy_func = (GDestroyNotify(*)(GeeMapIterator*)) gee_read_only_map_map_iterator_gee_map_iterator_get_v_destroy_func;
1094         iface->get_read_only = gee_read_only_map_map_iterator_real_get_read_only;
1095         iface->get_mutable = gee_read_only_map_map_iterator_real_get_mutable;
1096         iface->get_valid = gee_read_only_map_map_iterator_real_get_valid;
1097 }
1098
1099
1100 static void gee_read_only_map_map_iterator_instance_init (GeeReadOnlyMapMapIterator * self) {
1101         self->priv = GEE_READ_ONLY_MAP_MAP_ITERATOR_GET_PRIVATE (self);
1102 }
1103
1104
1105 static void gee_read_only_map_map_iterator_finalize (GObject* obj) {
1106         GeeReadOnlyMapMapIterator * self;
1107         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, GeeReadOnlyMapMapIterator);
1108         _g_object_unref0 (self->_iter);
1109         G_OBJECT_CLASS (gee_read_only_map_map_iterator_parent_class)->finalize (obj);
1110 }
1111
1112
1113 GType gee_read_only_map_map_iterator_get_type (void) {
1114         static volatile gsize gee_read_only_map_map_iterator_type_id__volatile = 0;
1115         if (g_once_init_enter (&gee_read_only_map_map_iterator_type_id__volatile)) {
1116                 static const GTypeInfo g_define_type_info = { sizeof (GeeReadOnlyMapMapIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_read_only_map_map_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeReadOnlyMapMapIterator), 0, (GInstanceInitFunc) gee_read_only_map_map_iterator_instance_init, NULL };
1117                 static const GInterfaceInfo gee_map_iterator_info = { (GInterfaceInitFunc) gee_read_only_map_map_iterator_gee_map_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1118                 GType gee_read_only_map_map_iterator_type_id;
1119                 gee_read_only_map_map_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeReadOnlyMapMapIterator", &g_define_type_info, 0);
1120                 g_type_add_interface_static (gee_read_only_map_map_iterator_type_id, GEE_TYPE_MAP_ITERATOR, &gee_map_iterator_info);
1121                 g_once_init_leave (&gee_read_only_map_map_iterator_type_id__volatile, gee_read_only_map_map_iterator_type_id);
1122         }
1123         return gee_read_only_map_map_iterator_type_id__volatile;
1124 }
1125
1126
1127 static void _vala_gee_read_only_map_map_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1128         GeeReadOnlyMapMapIterator * self;
1129         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, GeeReadOnlyMapMapIterator);
1130         switch (property_id) {
1131                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_READ_ONLY:
1132                 g_value_set_boolean (value, gee_map_iterator_get_read_only ((GeeMapIterator*) self));
1133                 break;
1134                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_MUTABLE:
1135                 g_value_set_boolean (value, gee_map_iterator_get_mutable ((GeeMapIterator*) self));
1136                 break;
1137                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_VALID:
1138                 g_value_set_boolean (value, gee_map_iterator_get_valid ((GeeMapIterator*) self));
1139                 break;
1140                 default:
1141                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1142                 break;
1143         }
1144 }
1145
1146
1147 static void _vala_gee_read_only_map_map_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1148         GeeReadOnlyMapMapIterator * self;
1149         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_MAP_TYPE_MAP_ITERATOR, GeeReadOnlyMapMapIterator);
1150         switch (property_id) {
1151                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_K_TYPE:
1152                 self->priv->k_type = g_value_get_gtype (value);
1153                 break;
1154                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_K_DUP_FUNC:
1155                 self->priv->k_dup_func = g_value_get_pointer (value);
1156                 break;
1157                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_K_DESTROY_FUNC:
1158                 self->priv->k_destroy_func = g_value_get_pointer (value);
1159                 break;
1160                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_V_TYPE:
1161                 self->priv->v_type = g_value_get_gtype (value);
1162                 break;
1163                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_V_DUP_FUNC:
1164                 self->priv->v_dup_func = g_value_get_pointer (value);
1165                 break;
1166                 case GEE_READ_ONLY_MAP_MAP_ITERATOR_V_DESTROY_FUNC:
1167                 self->priv->v_destroy_func = g_value_get_pointer (value);
1168                 break;
1169                 default:
1170                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1171                 break;
1172         }
1173 }
1174
1175
1176 static void gee_read_only_map_class_init (GeeReadOnlyMapClass * klass) {
1177         gee_read_only_map_parent_class = g_type_class_peek_parent (klass);
1178         g_type_class_add_private (klass, sizeof (GeeReadOnlyMapPrivate));
1179         GEE_READ_ONLY_MAP_CLASS (klass)->get_read_only_view = gee_read_only_map_real_get_read_only_view;
1180         G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_map_get_property;
1181         G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_map_set_property;
1182         G_OBJECT_CLASS (klass)->finalize = gee_read_only_map_finalize;
1183         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1184         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1185         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1186         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1187         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1188         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1189         /**
1190          * {@inheritDoc}
1191          */
1192         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1193         /**
1194          * {@inheritDoc}
1195          */
1196         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1197         /**
1198          * {@inheritDoc}
1199          */
1200         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1201         /**
1202          * {@inheritDoc}
1203          */
1204         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1205         /**
1206          * {@inheritDoc}
1207          */
1208         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1209         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_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));
1210         /**
1211          * {@inheritDoc}
1212          */
1213         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_MAP_KEY_TYPE, g_param_spec_gtype ("key-type", "key-type", "key-type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
1214         /**
1215          * {@inheritDoc}
1216          */
1217         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_MAP_VALUE_TYPE, g_param_spec_gtype ("value-type", "value-type", "value-type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
1218 }
1219
1220
1221 static GType gee_read_only_map_gee_traversable_get_g_type (GeeReadOnlyMap* self) {
1222         return GEE_MAP_TYPE_ENTRY;
1223 }
1224
1225
1226 static GBoxedCopyFunc gee_read_only_map_gee_traversable_get_g_dup_func (GeeReadOnlyMap* self) {
1227         return g_object_ref;
1228 }
1229
1230
1231 static GDestroyNotify gee_read_only_map_gee_traversable_get_g_destroy_func (GeeReadOnlyMap* self) {
1232         return g_object_unref;
1233 }
1234
1235
1236 static void gee_read_only_map_gee_traversable_interface_init (GeeTraversableIface * iface) {
1237         gee_read_only_map_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
1238         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_read_only_map_real_foreach;
1239         iface->stream = (GeeIterator* (*)(GeeTraversable*, GType, GBoxedCopyFunc, GDestroyNotify, GeeStreamFunc, void*, GDestroyNotify)) gee_read_only_map_real_stream;
1240         iface->filter = (GeeIterator* (*)(GeeTraversable*, GeePredicate, void*, GDestroyNotify)) gee_read_only_map_real_filter;
1241         iface->chop = (GeeIterator* (*)(GeeTraversable*, gint, gint)) gee_read_only_map_real_chop;
1242         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_read_only_map_gee_traversable_get_g_type;
1243         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_read_only_map_gee_traversable_get_g_dup_func;
1244         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_read_only_map_gee_traversable_get_g_destroy_func;
1245         iface->get_element_type = gee_read_only_map_real_get_element_type;
1246 }
1247
1248
1249 static GType gee_read_only_map_gee_iterable_get_g_type (GeeReadOnlyMap* self) {
1250         return GEE_MAP_TYPE_ENTRY;
1251 }
1252
1253
1254 static GBoxedCopyFunc gee_read_only_map_gee_iterable_get_g_dup_func (GeeReadOnlyMap* self) {
1255         return g_object_ref;
1256 }
1257
1258
1259 static GDestroyNotify gee_read_only_map_gee_iterable_get_g_destroy_func (GeeReadOnlyMap* self) {
1260         return g_object_unref;
1261 }
1262
1263
1264 static void gee_read_only_map_gee_iterable_interface_init (GeeIterableIface * iface) {
1265         gee_read_only_map_gee_iterable_parent_iface = g_type_interface_peek_parent (iface);
1266         iface->iterator = (GeeIterator* (*)(GeeIterable*)) gee_read_only_map_real_iterator;
1267         iface->get_g_type = (GType(*)(GeeIterable*)) gee_read_only_map_gee_iterable_get_g_type;
1268         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeIterable*)) gee_read_only_map_gee_iterable_get_g_dup_func;
1269         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeIterable*)) gee_read_only_map_gee_iterable_get_g_destroy_func;
1270 }
1271
1272
1273 static GType gee_read_only_map_gee_map_get_k_type (GeeReadOnlyMap* self) {
1274         return self->priv->k_type;
1275 }
1276
1277
1278 static GBoxedCopyFunc gee_read_only_map_gee_map_get_k_dup_func (GeeReadOnlyMap* self) {
1279         return self->priv->k_dup_func;
1280 }
1281
1282
1283 static GDestroyNotify gee_read_only_map_gee_map_get_k_destroy_func (GeeReadOnlyMap* self) {
1284         return self->priv->k_destroy_func;
1285 }
1286
1287
1288 static GType gee_read_only_map_gee_map_get_v_type (GeeReadOnlyMap* self) {
1289         return self->priv->v_type;
1290 }
1291
1292
1293 static GBoxedCopyFunc gee_read_only_map_gee_map_get_v_dup_func (GeeReadOnlyMap* self) {
1294         return self->priv->v_dup_func;
1295 }
1296
1297
1298 static GDestroyNotify gee_read_only_map_gee_map_get_v_destroy_func (GeeReadOnlyMap* self) {
1299         return self->priv->v_destroy_func;
1300 }
1301
1302
1303 static void gee_read_only_map_gee_map_interface_init (GeeMapIface * iface) {
1304         gee_read_only_map_gee_map_parent_iface = g_type_interface_peek_parent (iface);
1305         iface->has_key = (gboolean (*)(GeeMap*, gconstpointer)) gee_read_only_map_real_has_key;
1306         iface->has = (gboolean (*)(GeeMap*, gconstpointer, gconstpointer)) gee_read_only_map_real_has;
1307         iface->get = (gpointer (*)(GeeMap*, gconstpointer)) gee_read_only_map_real_get;
1308         iface->set = (void (*)(GeeMap*, gconstpointer, gconstpointer)) gee_read_only_map_real_set;
1309         iface->unset = (gboolean (*)(GeeMap*, gconstpointer, gpointer*)) gee_read_only_map_real_unset;
1310         iface->clear = (void (*)(GeeMap*)) gee_read_only_map_real_clear;
1311         iface->map_iterator = (GeeMapIterator* (*)(GeeMap*)) gee_read_only_map_real_map_iterator;
1312         iface->set_all = (void (*)(GeeMap*, GeeMap*)) gee_read_only_map_real_set_all;
1313         iface->unset_all = (gboolean (*)(GeeMap*, GeeMap*)) gee_read_only_map_real_unset_all;
1314         iface->has_all = (gboolean (*)(GeeMap*, GeeMap*)) gee_read_only_map_real_has_all;
1315         iface->get_k_type = (GType(*)(GeeMap*)) gee_read_only_map_gee_map_get_k_type;
1316         iface->get_k_dup_func = (GBoxedCopyFunc(*)(GeeMap*)) gee_read_only_map_gee_map_get_k_dup_func;
1317         iface->get_k_destroy_func = (GDestroyNotify(*)(GeeMap*)) gee_read_only_map_gee_map_get_k_destroy_func;
1318         iface->get_v_type = (GType(*)(GeeMap*)) gee_read_only_map_gee_map_get_v_type;
1319         iface->get_v_dup_func = (GBoxedCopyFunc(*)(GeeMap*)) gee_read_only_map_gee_map_get_v_dup_func;
1320         iface->get_v_destroy_func = (GDestroyNotify(*)(GeeMap*)) gee_read_only_map_gee_map_get_v_destroy_func;
1321         iface->get_size = gee_read_only_map_real_get_size;
1322         iface->get_is_empty = gee_read_only_map_real_get_is_empty;
1323         iface->get_read_only = gee_read_only_map_real_get_read_only;
1324         iface->get_keys = gee_read_only_map_real_get_keys;
1325         iface->get_values = gee_read_only_map_real_get_values;
1326         iface->get_entries = gee_read_only_map_real_get_entries;
1327         iface->get_read_only_view = (GeeMap* (*) (GeeMap *)) gee_read_only_map_get_read_only_view;
1328 }
1329
1330
1331 static void gee_read_only_map_instance_init (GeeReadOnlyMap * self) {
1332         self->priv = GEE_READ_ONLY_MAP_GET_PRIVATE (self);
1333 }
1334
1335
1336 static void gee_read_only_map_finalize (GObject* obj) {
1337         GeeReadOnlyMap * self;
1338         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMap);
1339         _g_object_unref0 (self->_map);
1340         G_OBJECT_CLASS (gee_read_only_map_parent_class)->finalize (obj);
1341 }
1342
1343
1344 /**
1345  * Read-only view for {@link Map} collections.
1346  *
1347  * This class decorates any class which implements the {@link Map} interface
1348  * by making it read only. Any method which normally modify data will throw an
1349  * error.
1350  *
1351  * @see Map
1352  */
1353 GType gee_read_only_map_get_type (void) {
1354         static volatile gsize gee_read_only_map_type_id__volatile = 0;
1355         if (g_once_init_enter (&gee_read_only_map_type_id__volatile)) {
1356                 static const GTypeInfo g_define_type_info = { sizeof (GeeReadOnlyMapClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_read_only_map_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeReadOnlyMap), 0, (GInstanceInitFunc) gee_read_only_map_instance_init, NULL };
1357                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_read_only_map_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1358                 static const GInterfaceInfo gee_iterable_info = { (GInterfaceInitFunc) gee_read_only_map_gee_iterable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1359                 static const GInterfaceInfo gee_map_info = { (GInterfaceInitFunc) gee_read_only_map_gee_map_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1360                 GType gee_read_only_map_type_id;
1361                 gee_read_only_map_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeReadOnlyMap", &g_define_type_info, 0);
1362                 g_type_add_interface_static (gee_read_only_map_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
1363                 g_type_add_interface_static (gee_read_only_map_type_id, GEE_TYPE_ITERABLE, &gee_iterable_info);
1364                 g_type_add_interface_static (gee_read_only_map_type_id, GEE_TYPE_MAP, &gee_map_info);
1365                 g_once_init_leave (&gee_read_only_map_type_id__volatile, gee_read_only_map_type_id);
1366         }
1367         return gee_read_only_map_type_id__volatile;
1368 }
1369
1370
1371 static void _vala_gee_read_only_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1372         GeeReadOnlyMap * self;
1373         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMap);
1374         switch (property_id) {
1375                 case GEE_READ_ONLY_MAP_SIZE:
1376                 g_value_set_int (value, gee_map_get_size ((GeeMap*) self));
1377                 break;
1378                 case GEE_READ_ONLY_MAP_READ_ONLY:
1379                 g_value_set_boolean (value, gee_map_get_read_only ((GeeMap*) self));
1380                 break;
1381                 case GEE_READ_ONLY_MAP_KEYS:
1382                 g_value_take_object (value, gee_map_get_keys ((GeeMap*) self));
1383                 break;
1384                 case GEE_READ_ONLY_MAP_VALUES:
1385                 g_value_take_object (value, gee_map_get_values ((GeeMap*) self));
1386                 break;
1387                 case GEE_READ_ONLY_MAP_ENTRIES:
1388                 g_value_take_object (value, gee_map_get_entries ((GeeMap*) self));
1389                 break;
1390                 case GEE_READ_ONLY_MAP_READ_ONLY_VIEW:
1391                 g_value_take_object (value, gee_read_only_map_get_read_only_view (self));
1392                 break;
1393                 case GEE_READ_ONLY_MAP_KEY_TYPE:
1394                 g_value_set_gtype (value, gee_read_only_map_get_key_type (self));
1395                 break;
1396                 case GEE_READ_ONLY_MAP_VALUE_TYPE:
1397                 g_value_set_gtype (value, gee_read_only_map_get_value_type (self));
1398                 break;
1399                 default:
1400                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1401                 break;
1402         }
1403 }
1404
1405
1406 static void _vala_gee_read_only_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1407         GeeReadOnlyMap * self;
1408         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_MAP, GeeReadOnlyMap);
1409         switch (property_id) {
1410                 case GEE_READ_ONLY_MAP_K_TYPE:
1411                 self->priv->k_type = g_value_get_gtype (value);
1412                 break;
1413                 case GEE_READ_ONLY_MAP_K_DUP_FUNC:
1414                 self->priv->k_dup_func = g_value_get_pointer (value);
1415                 break;
1416                 case GEE_READ_ONLY_MAP_K_DESTROY_FUNC:
1417                 self->priv->k_destroy_func = g_value_get_pointer (value);
1418                 break;
1419                 case GEE_READ_ONLY_MAP_V_TYPE:
1420                 self->priv->v_type = g_value_get_gtype (value);
1421                 break;
1422                 case GEE_READ_ONLY_MAP_V_DUP_FUNC:
1423                 self->priv->v_dup_func = g_value_get_pointer (value);
1424                 break;
1425                 case GEE_READ_ONLY_MAP_V_DESTROY_FUNC:
1426                 self->priv->v_destroy_func = g_value_get_pointer (value);
1427                 break;
1428                 default:
1429                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1430                 break;
1431         }
1432 }
1433
1434
1435