gee/map.c

   1 /* map.c generated by valac 0.18.0, the Vala compiler
   2  * generated from map.vala, do not modify */
   3
   4 /* map.vala
   5  *
   6  * Copyright (C) 2007  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 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 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
 119 #define GEE_TYPE_HASH_MAP (gee_hash_map_get_type ())
 120 #define GEE_HASH_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_HASH_MAP, GeeHashMap))
 121 #define GEE_HASH_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_HASH_MAP, GeeHashMapClass))
 122 #define GEE_IS_HASH_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_HASH_MAP))
 123 #define GEE_IS_HASH_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_HASH_MAP))
 124 #define GEE_HASH_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_HASH_MAP, GeeHashMapClass))
 125
 126 typedef struct _GeeHashMap GeeHashMap;
 127 typedef struct _GeeHashMapClass GeeHashMapClass;
 128 typedef struct _GeeMapEntryPrivate GeeMapEntryPrivate;
 129
 130 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 131 typedef enum  {
 132         GEE_TRAVERSABLE_STREAM_YIELD,
 133         GEE_TRAVERSABLE_STREAM_CONTINUE,
 134         GEE_TRAVERSABLE_STREAM_END
 135 } GeeTraversableStream;
 136
 137 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 138 struct _GeeIteratorIface {
 139         GTypeInterface parent_iface;
 140         gboolean (*next) (GeeIterator* self);
 141         gboolean (*has_next) (GeeIterator* self);
 142         gpointer (*get) (GeeIterator* self);
 143         void (*remove) (GeeIterator* self);
 144         gboolean (*get_valid) (GeeIterator* self);
 145         gboolean (*get_read_only) (GeeIterator* self);
 146 };
 147
 148 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 149 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 150 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 151 struct _GeeTraversableIface {
 152         GTypeInterface parent_iface;
 153         GType (*get_g_type) (GeeTraversable* self);
 154         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 155         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 156         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 157         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);
 158         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 159         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 160         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 161         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 162         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 163         GType (*get_element_type) (GeeTraversable* self);
 164 };
 165
 166 struct _GeeIterableIface {
 167         GTypeInterface parent_iface;
 168         GType (*get_g_type) (GeeIterable* self);
 169         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 170         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 171         GeeIterator* (*iterator) (GeeIterable* self);
 172 };
 173
 174 typedef gpointer (*GeeFoldMapFunc) (gconstpointer k, gconstpointer v, gpointer a, void* user_data);
 175 typedef gboolean (*GeeForallMapFunc) (gconstpointer k, gconstpointer v, void* user_data);
 176 struct _GeeMapIteratorIface {
 177         GTypeInterface parent_iface;
 178         GType (*get_k_type) (GeeMapIterator* self);
 179         GBoxedCopyFunc (*get_k_dup_func) (GeeMapIterator* self);
 180         GDestroyNotify (*get_k_destroy_func) (GeeMapIterator* self);
 181         GType (*get_v_type) (GeeMapIterator* self);
 182         GBoxedCopyFunc (*get_v_dup_func) (GeeMapIterator* self);
 183         GDestroyNotify (*get_v_destroy_func) (GeeMapIterator* self);
 184         gboolean (*next) (GeeMapIterator* self);
 185         gboolean (*has_next) (GeeMapIterator* self);
 186         gpointer (*get_key) (GeeMapIterator* self);
 187         gpointer (*get_value) (GeeMapIterator* self);
 188         void (*set_value) (GeeMapIterator* self, gconstpointer value);
 189         void (*unset) (GeeMapIterator* self);
 190         gpointer (*fold) (GeeMapIterator* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldMapFunc f, void* f_target, gpointer seed);
 191         gboolean (*foreach) (GeeMapIterator* self, GeeForallMapFunc f, void* f_target);
 192         gboolean (*get_valid) (GeeMapIterator* self);
 193         gboolean (*get_mutable) (GeeMapIterator* self);
 194         gboolean (*get_read_only) (GeeMapIterator* self);
 195 };
 196
 197 struct _GeeCollectionIface {
 198         GTypeInterface parent_iface;
 199         GType (*get_g_type) (GeeCollection* self);
 200         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 201         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 202         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 203         gboolean (*add) (GeeCollection* self, gconstpointer item);
 204         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 205         void (*clear) (GeeCollection* self);
 206         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 207         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 208         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 209         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 210         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 211         gint (*get_size) (GeeCollection* self);
 212         gboolean (*get_is_empty) (GeeCollection* self);
 213         gboolean (*get_read_only) (GeeCollection* self);
 214         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 215 };
 216
 217 struct _GeeSetIface {
 218         GTypeInterface parent_iface;
 219         GType (*get_g_type) (GeeSet* self);
 220         GBoxedCopyFunc (*get_g_dup_func) (GeeSet* self);
 221         GDestroyNotify (*get_g_destroy_func) (GeeSet* self);
 222         GeeSet* (*get_read_only_view) (GeeSet* self);
 223 };
 224
 225 struct _GeeMapIface {
 226         GTypeInterface parent_iface;
 227         GType (*get_k_type) (GeeMap* self);
 228         GBoxedCopyFunc (*get_k_dup_func) (GeeMap* self);
 229         GDestroyNotify (*get_k_destroy_func) (GeeMap* self);
 230         GType (*get_v_type) (GeeMap* self);
 231         GBoxedCopyFunc (*get_v_dup_func) (GeeMap* self);
 232         GDestroyNotify (*get_v_destroy_func) (GeeMap* self);
 233         gboolean (*has_key) (GeeMap* self, gconstpointer key);
 234         gboolean (*has) (GeeMap* self, gconstpointer key, gconstpointer value);
 235         gpointer (*get) (GeeMap* self, gconstpointer key);
 236         void (*set) (GeeMap* self, gconstpointer key, gconstpointer value);
 237         gboolean (*unset) (GeeMap* self, gconstpointer key, gpointer* value);
 238         void (*clear) (GeeMap* self);
 239         GeeMapIterator* (*map_iterator) (GeeMap* self);
 240         void (*set_all) (GeeMap* self, GeeMap* map);
 241         gboolean (*unset_all) (GeeMap* self, GeeMap* map);
 242         gboolean (*has_all) (GeeMap* self, GeeMap* map);
 243         gint (*get_size) (GeeMap* self);
 244         gboolean (*get_is_empty) (GeeMap* self);
 245         gboolean (*get_read_only) (GeeMap* self);
 246         GeeSet* (*get_keys) (GeeMap* self);
 247         GeeCollection* (*get_values) (GeeMap* self);
 248         GeeSet* (*get_entries) (GeeMap* self);
 249         GeeMap* (*get_read_only_view) (GeeMap* self);
 250 };
 251
 252 typedef guint (*GeeHashDataFunc) (gconstpointer v, void* user_data);
 253 typedef gboolean (*GeeEqualDataFunc) (gconstpointer a, gconstpointer b, void* user_data);
 254 struct _GeeMapEntry {
 255         GObject parent_instance;
 256         GeeMapEntryPrivate * priv;
 257 };
 258
 259 struct _GeeMapEntryClass {
 260         GObjectClass parent_class;
 261         gconstpointer (*get_key) (GeeMapEntry* self);
 262         gconstpointer (*get_value) (GeeMapEntry* self);
 263         void (*set_value) (GeeMapEntry* self, gconstpointer value);
 264         gboolean (*get_read_only) (GeeMapEntry* self);
 265 };
 266
 267 struct _GeeMapEntryPrivate {
 268         GType k_type;
 269         GBoxedCopyFunc k_dup_func;
 270         GDestroyNotify k_destroy_func;
 271         GType v_type;
 272         GBoxedCopyFunc v_dup_func;
 273         GDestroyNotify v_destroy_func;
 274 };
 275
 276
 277 static gpointer gee_map_entry_parent_class = NULL;
 278
 279 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 280 gpointer gee_lazy_ref (gpointer instance);
 281 void gee_lazy_unref (gpointer instance);
 282 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 283 void gee_value_set_lazy (GValue* value, gpointer v_object);
 284 void gee_value_take_lazy (GValue* value, gpointer v_object);
 285 gpointer gee_value_get_lazy (const GValue* value);
 286 GType gee_lazy_get_type (void) G_GNUC_CONST;
 287 GType gee_iterator_get_type (void) G_GNUC_CONST;
 288 GType gee_traversable_get_type (void) G_GNUC_CONST;
 289 GType gee_iterable_get_type (void) G_GNUC_CONST;
 290 GType gee_map_iterator_get_type (void) G_GNUC_CONST;
 291 GType gee_collection_get_type (void) G_GNUC_CONST;
 292 GType gee_set_get_type (void) G_GNUC_CONST;
 293 GType gee_map_entry_get_type (void) G_GNUC_CONST;
 294 GType gee_map_get_type (void) G_GNUC_CONST;
 295 gboolean gee_map_has_key (GeeMap* self, gconstpointer key);
 296 gboolean gee_map_contains (GeeMap* self, gconstpointer key) G_GNUC_DEPRECATED;
 297 gboolean gee_map_has (GeeMap* self, gconstpointer key, gconstpointer value);
 298 gpointer gee_map_get (GeeMap* self, gconstpointer key);
 299 void gee_map_set (GeeMap* self, gconstpointer key, gconstpointer value);
 300 gboolean gee_map_unset (GeeMap* self, gconstpointer key, gpointer* value);
 301 gboolean gee_map_remove (GeeMap* self, gconstpointer key, gpointer* value) G_GNUC_DEPRECATED;
 302 void gee_map_clear (GeeMap* self);
 303 GeeMapIterator* gee_map_map_iterator (GeeMap* self);
 304 void gee_map_set_all (GeeMap* self, GeeMap* map);
 305 static void gee_map_real_set_all (GeeMap* self, GeeMap* map);
 306 GeeSet* gee_map_get_entries (GeeMap* self);
 307 GeeIterator* gee_iterable_iterator (GeeIterable* self);
 308 gboolean gee_iterator_next (GeeIterator* self);
 309 gpointer gee_iterator_get (GeeIterator* self);
 310 gconstpointer gee_map_entry_get_key (GeeMapEntry* self);
 311 gconstpointer gee_map_entry_get_value (GeeMapEntry* self);
 312 gboolean gee_map_unset_all (GeeMap* self, GeeMap* map);
 313 static gboolean gee_map_real_unset_all (GeeMap* self, GeeMap* map);
 314 GeeSet* gee_map_get_keys (GeeMap* self);
 315 gboolean gee_map_remove_all (GeeMap* self, GeeMap* map) G_GNUC_DEPRECATED;
 316 gboolean gee_map_has_all (GeeMap* self, GeeMap* map);
 317 static gboolean gee_map_real_has_all (GeeMap* self, GeeMap* map);
 318 gboolean gee_map_contains_all (GeeMap* self, GeeMap* map) G_GNUC_DEPRECATED;
 319 GeeMap* gee_map_empty (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func);
 320 GeeHashMap* gee_hash_map_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashDataFunc key_hash_func, void* key_hash_func_target, GDestroyNotify key_hash_func_target_destroy_notify, GeeEqualDataFunc key_equal_func, void* key_equal_func_target, GDestroyNotify key_equal_func_target_destroy_notify, GeeEqualDataFunc value_equal_func, void* value_equal_func_target, GDestroyNotify value_equal_func_target_destroy_notify);
 321 GeeHashMap* gee_hash_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeHashDataFunc key_hash_func, void* key_hash_func_target, GDestroyNotify key_hash_func_target_destroy_notify, GeeEqualDataFunc key_equal_func, void* key_equal_func_target, GDestroyNotify key_equal_func_target_destroy_notify, GeeEqualDataFunc value_equal_func, void* value_equal_func_target, GDestroyNotify value_equal_func_target_destroy_notify);
 322 GType gee_abstract_map_get_type (void) G_GNUC_CONST;
 323 GType gee_hash_map_get_type (void) G_GNUC_CONST;
 324 GeeMap* gee_abstract_map_get_read_only_view (GeeAbstractMap* self);
 325 gint gee_map_get_size (GeeMap* self);
 326 gboolean gee_map_get_is_empty (GeeMap* self);
 327 gboolean gee_map_get_read_only (GeeMap* self);
 328 GeeCollection* gee_map_get_values (GeeMap* self);
 329 GeeMap* gee_map_get_read_only_view (GeeMap* self);
 330 GType gee_map_get_key_type (GeeMap* self);
 331 GType gee_map_get_value_type (GeeMap* self);
 332 #define GEE_MAP_ENTRY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_MAP_TYPE_ENTRY, GeeMapEntryPrivate))
 333 enum  {
 334         GEE_MAP_ENTRY_DUMMY_PROPERTY,
 335         GEE_MAP_ENTRY_K_TYPE,
 336         GEE_MAP_ENTRY_K_DUP_FUNC,
 337         GEE_MAP_ENTRY_K_DESTROY_FUNC,
 338         GEE_MAP_ENTRY_V_TYPE,
 339         GEE_MAP_ENTRY_V_DUP_FUNC,
 340         GEE_MAP_ENTRY_V_DESTROY_FUNC,
 341         GEE_MAP_ENTRY_KEY,
 342         GEE_MAP_ENTRY_VALUE,
 343         GEE_MAP_ENTRY_READ_ONLY
 344 };
 345 GeeMapEntry* gee_map_entry_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func);
 346 void gee_map_entry_set_value (GeeMapEntry* self, gconstpointer value);
 347 gboolean gee_map_entry_get_read_only (GeeMapEntry* self);
 348 static void _vala_gee_map_entry_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 349 static void _vala_gee_map_entry_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 350
 351
 352 /**
 353  * Determines whether this map has the specified key.
 354  *
 355  * @param key the key to locate in the map
 356  *
 357  * @return    ``true`` if key is found, ``false`` otherwise
 358  */
 359 gboolean gee_map_has_key (GeeMap* self, gconstpointer key) {
 360         g_return_val_if_fail (self != NULL, FALSE);
 361         return GEE_MAP_GET_INTERFACE (self)->has_key (self, key);
 362 }
 363
 364
 365 /**
 366  * Determines whether this map contains the specified key.
 367  *
 368  * @param key the key to locate in the map
 369  *
 370  * @return    ``true`` if key is found, ``false`` otherwise
 371  */
 372 gboolean gee_map_contains (GeeMap* self, gconstpointer key) {
 373         gboolean result = FALSE;
 374         gconstpointer _tmp0_;
 375         gboolean _tmp1_ = FALSE;
 376         _tmp0_ = key;
 377         _tmp1_ = gee_map_has_key (self, _tmp0_);
 378         result = _tmp1_;
 379         return result;
 380 }
 381
 382
 383 /**
 384  * Determines whether this map has the specified key/value entry.
 385  *
 386  * @param key the key to locate in the map
 387  * @param value the corresponding value
 388  *
 389  * @return    ``true`` if key is found, ``false`` otherwise
 390  */
 391 gboolean gee_map_has (GeeMap* self, gconstpointer key, gconstpointer value) {
 392         g_return_val_if_fail (self != NULL, FALSE);
 393         return GEE_MAP_GET_INTERFACE (self)->has (self, key, value);
 394 }
 395
 396
 397 /**
 398  * Returns the value of the specified key in this map.
 399  *
 400  * @param key the key whose value is to be retrieved
 401  *
 402  * @return    the value associated with the key, or ``null`` if the key
 403  *            couldn't be found
 404  */
 405 gpointer gee_map_get (GeeMap* self, gconstpointer key) {
 406         g_return_val_if_fail (self != NULL, NULL);
 407         return GEE_MAP_GET_INTERFACE (self)->get (self, key);
 408 }
 409
 410
 411 /**
 412  * Inserts a new key and value into this map.
 413  *
 414  * @param key   the key to insert
 415  * @param value the value to associate with the key
 416  */
 417 void gee_map_set (GeeMap* self, gconstpointer key, gconstpointer value) {
 418         g_return_if_fail (self != NULL);
 419         GEE_MAP_GET_INTERFACE (self)->set (self, key, value);
 420 }
 421
 422
 423 /**
 424  * Removes the specified key from this map.
 425  *
 426  * @param key   the key to remove from the map
 427  * @param value the receiver variable for the removed value
 428  *
 429  * @return    ``true`` if the map has been changed, ``false`` otherwise
 430  */
 431 gboolean gee_map_unset (GeeMap* self, gconstpointer key, gpointer* value) {
 432         g_return_val_if_fail (self != NULL, FALSE);
 433         return GEE_MAP_GET_INTERFACE (self)->unset (self, key, value);
 434 }
 435
 436
 437 /**
 438  * Removes the specified key from this map.
 439  *
 440  * @param key   the key to remove from the map
 441  * @param value the receiver variable for the removed value
 442  *
 443  * @return    ``true`` if the map has been changed, ``false`` otherwise
 444  */
 445 gboolean gee_map_remove (GeeMap* self, gconstpointer key, gpointer* value) {
 446         gpointer _vala_value = NULL;
 447         gboolean result = FALSE;
 448         gconstpointer _tmp0_;
 449         gpointer _tmp1_ = NULL;
 450         gboolean _tmp2_ = FALSE;
 451         _tmp0_ = key;
 452         _tmp2_ = gee_map_unset (self, _tmp0_, &_tmp1_);
 453         ((_vala_value == NULL) || (GEE_MAP_GET_INTERFACE (self)->get_v_destroy_func (self) == NULL)) ? NULL : (_vala_value = (GEE_MAP_GET_INTERFACE (self)->get_v_destroy_func (self) (_vala_value), NULL));
 454         _vala_value = _tmp1_;
 455         result = _tmp2_;
 456         if (value) {
 457                 *value = _vala_value;
 458         } else {
 459                 ((_vala_value == NULL) || (GEE_MAP_GET_INTERFACE (self)->get_v_destroy_func (self) == NULL)) ? NULL : (_vala_value = (GEE_MAP_GET_INTERFACE (self)->get_v_destroy_func (self) (_vala_value), NULL));
 460         }
 461         return result;
 462 }
 463
 464
 465 /**
 466  * Removes all items from this collection. Must not be called on
 467  * read-only collections.
 468  */
 469 void gee_map_clear (GeeMap* self) {
 470         g_return_if_fail (self != NULL);
 471         GEE_MAP_GET_INTERFACE (self)->clear (self);
 472 }
 473
 474
 475 /**
 476  * Returns an iterator for this map.
 477  *
 478  * @return a map iterator
 479  */
 480 GeeMapIterator* gee_map_map_iterator (GeeMap* self) {
 481         g_return_val_if_fail (self != NULL, NULL);
 482         return GEE_MAP_GET_INTERFACE (self)->map_iterator (self);
 483 }
 484
 485
 486 /**
 487  * Inserts all items that are contained in the input map to this map.
 488  *
 489  * @param map the map which items are inserted to this map
 490  */
 491 static void gee_map_real_set_all (GeeMap* self, GeeMap* map) {
 492         g_return_if_fail (map != NULL);
 493         {
 494                 GeeMap* _tmp0_;
 495                 GeeSet* _tmp1_;
 496                 GeeSet* _tmp2_;
 497                 GeeSet* _tmp3_;
 498                 GeeIterator* _tmp4_ = NULL;
 499                 GeeIterator* _tmp5_;
 500                 GeeIterator* _entry_it;
 501                 _tmp0_ = map;
 502                 _tmp1_ = gee_map_get_entries (_tmp0_);
 503                 _tmp2_ = _tmp1_;
 504                 _tmp3_ = _tmp2_;
 505                 _tmp4_ = gee_iterable_iterator ((GeeIterable*) _tmp3_);
 506                 _tmp5_ = _tmp4_;
 507                 _g_object_unref0 (_tmp3_);
 508                 _entry_it = _tmp5_;
 509                 while (TRUE) {
 510                         GeeIterator* _tmp6_;
 511                         gboolean _tmp7_ = FALSE;
 512                         GeeIterator* _tmp8_;
 513                         gpointer _tmp9_ = NULL;
 514                         GeeMapEntry* entry;
 515                         GeeMapEntry* _tmp10_;
 516                         gconstpointer _tmp11_;
 517                         gconstpointer _tmp12_;
 518                         GeeMapEntry* _tmp13_;
 519                         gconstpointer _tmp14_;
 520                         gconstpointer _tmp15_;
 521                         _tmp6_ = _entry_it;
 522                         _tmp7_ = gee_iterator_next (_tmp6_);
 523                         if (!_tmp7_) {
 524                                 break;
 525                         }
 526                         _tmp8_ = _entry_it;
 527                         _tmp9_ = gee_iterator_get (_tmp8_);
 528                         entry = (GeeMapEntry*) _tmp9_;
 529                         _tmp10_ = entry;
 530                         _tmp11_ = gee_map_entry_get_key (_tmp10_);
 531                         _tmp12_ = _tmp11_;
 532                         _tmp13_ = entry;
 533                         _tmp14_ = gee_map_entry_get_value (_tmp13_);
 534                         _tmp15_ = _tmp14_;
 535                         gee_map_set (self, _tmp12_, _tmp15_);
 536                         _g_object_unref0 (entry);
 537                 }
 538                 _g_object_unref0 (_entry_it);
 539         }
 540 }
 541
 542
 543 void gee_map_set_all (GeeMap* self, GeeMap* map) {
 544         g_return_if_fail (self != NULL);
 545         GEE_MAP_GET_INTERFACE (self)->set_all (self, map);
 546 }
 547
 548
 549 /**
 550  * Removes all items from this map that are common to the input map
 551  * and this map.
 552  *
 553  * @param map the map which common items are deleted from this map
 554  */
 555 static gboolean gee_map_real_unset_all (GeeMap* self, GeeMap* map) {
 556         gboolean result = FALSE;
 557         gboolean changed;
 558         g_return_val_if_fail (map != NULL, FALSE);
 559         changed = FALSE;
 560         {
 561                 GeeMap* _tmp0_;
 562                 GeeSet* _tmp1_;
 563                 GeeSet* _tmp2_;
 564                 GeeSet* _tmp3_;
 565                 GeeIterator* _tmp4_ = NULL;
 566                 GeeIterator* _tmp5_;
 567                 GeeIterator* _key_it;
 568                 _tmp0_ = map;
 569                 _tmp1_ = gee_map_get_keys (_tmp0_);
 570                 _tmp2_ = _tmp1_;
 571                 _tmp3_ = _tmp2_;
 572                 _tmp4_ = gee_iterable_iterator ((GeeIterable*) _tmp3_);
 573                 _tmp5_ = _tmp4_;
 574                 _g_object_unref0 (_tmp3_);
 575                 _key_it = _tmp5_;
 576                 while (TRUE) {
 577                         GeeIterator* _tmp6_;
 578                         gboolean _tmp7_ = FALSE;
 579                         GeeIterator* _tmp8_;
 580                         gpointer _tmp9_ = NULL;
 581                         gpointer key;
 582                         gboolean _tmp10_;
 583                         gconstpointer _tmp11_;
 584                         gboolean _tmp12_ = FALSE;
 585                         _tmp6_ = _key_it;
 586                         _tmp7_ = gee_iterator_next (_tmp6_);
 587                         if (!_tmp7_) {
 588                                 break;
 589                         }
 590                         _tmp8_ = _key_it;
 591                         _tmp9_ = gee_iterator_get (_tmp8_);
 592                         key = _tmp9_;
 593                         _tmp10_ = changed;
 594                         _tmp11_ = key;
 595                         _tmp12_ = gee_map_unset (self, _tmp11_, NULL);
 596                         changed = _tmp10_ | _tmp12_;
 597                         ((key == NULL) || (GEE_MAP_GET_INTERFACE (self)->get_k_destroy_func (self) == NULL)) ? NULL : (key = (GEE_MAP_GET_INTERFACE (self)->get_k_destroy_func (self) (key), NULL));
 598                 }
 599                 _g_object_unref0 (_key_it);
 600         }
 601         result = changed;
 602         return result;
 603 }
 604
 605
 606 gboolean gee_map_unset_all (GeeMap* self, GeeMap* map) {
 607         g_return_val_if_fail (self != NULL, FALSE);
 608         return GEE_MAP_GET_INTERFACE (self)->unset_all (self, map);
 609 }
 610
 611
 612 /**
 613  * Removes all items from this map that are common to the input map
 614  * and this map.
 615  *
 616  * @param map the map which common items are deleted from this map
 617  */
 618 gboolean gee_map_remove_all (GeeMap* self, GeeMap* map) {
 619         gboolean result = FALSE;
 620         GeeMap* _tmp0_;
 621         gboolean _tmp1_ = FALSE;
 622         g_return_val_if_fail (map != NULL, FALSE);
 623         _tmp0_ = map;
 624         _tmp1_ = gee_map_unset_all (self, _tmp0_);
 625         result = _tmp1_;
 626         return result;
 627 }
 628
 629
 630 /**
 631  * Returns ``true`` it this map contains all items as the input map.
 632  *
 633  * @param map the map which items will be compared with this map
 634  */
 635 static gboolean gee_map_real_has_all (GeeMap* self, GeeMap* map) {
 636         gboolean result = FALSE;
 637         g_return_val_if_fail (map != NULL, FALSE);
 638         {
 639                 GeeMap* _tmp0_;
 640                 GeeSet* _tmp1_;
 641                 GeeSet* _tmp2_;
 642                 GeeSet* _tmp3_;
 643                 GeeIterator* _tmp4_ = NULL;
 644                 GeeIterator* _tmp5_;
 645                 GeeIterator* _entry_it;
 646                 _tmp0_ = map;
 647                 _tmp1_ = gee_map_get_entries (_tmp0_);
 648                 _tmp2_ = _tmp1_;
 649                 _tmp3_ = _tmp2_;
 650                 _tmp4_ = gee_iterable_iterator ((GeeIterable*) _tmp3_);
 651                 _tmp5_ = _tmp4_;
 652                 _g_object_unref0 (_tmp3_);
 653                 _entry_it = _tmp5_;
 654                 while (TRUE) {
 655                         GeeIterator* _tmp6_;
 656                         gboolean _tmp7_ = FALSE;
 657                         GeeIterator* _tmp8_;
 658                         gpointer _tmp9_ = NULL;
 659                         GeeMapEntry* entry;
 660                         GeeMapEntry* _tmp10_;
 661                         gconstpointer _tmp11_;
 662                         gconstpointer _tmp12_;
 663                         GeeMapEntry* _tmp13_;
 664                         gconstpointer _tmp14_;
 665                         gconstpointer _tmp15_;
 666                         gboolean _tmp16_ = FALSE;
 667                         _tmp6_ = _entry_it;
 668                         _tmp7_ = gee_iterator_next (_tmp6_);
 669                         if (!_tmp7_) {
 670                                 break;
 671                         }
 672                         _tmp8_ = _entry_it;
 673                         _tmp9_ = gee_iterator_get (_tmp8_);
 674                         entry = (GeeMapEntry*) _tmp9_;
 675                         _tmp10_ = entry;
 676                         _tmp11_ = gee_map_entry_get_key (_tmp10_);
 677                         _tmp12_ = _tmp11_;
 678                         _tmp13_ = entry;
 679                         _tmp14_ = gee_map_entry_get_value (_tmp13_);
 680                         _tmp15_ = _tmp14_;
 681                         _tmp16_ = gee_map_has (self, _tmp12_, _tmp15_);
 682                         if (!_tmp16_) {
 683                                 result = FALSE;
 684                                 _g_object_unref0 (entry);
 685                                 _g_object_unref0 (_entry_it);
 686                                 return result;
 687                         }
 688                         _g_object_unref0 (entry);
 689                 }
 690                 _g_object_unref0 (_entry_it);
 691         }
 692         result = TRUE;
 693         return result;
 694 }
 695
 696
 697 gboolean gee_map_has_all (GeeMap* self, GeeMap* map) {
 698         g_return_val_if_fail (self != NULL, FALSE);
 699         return GEE_MAP_GET_INTERFACE (self)->has_all (self, map);
 700 }
 701
 702
 703 /**
 704  * Returns ``true`` it this map contains all items as the input map.
 705  *
 706  * @param map the map which items will be compared with this map
 707  */
 708 gboolean gee_map_contains_all (GeeMap* self, GeeMap* map) {
 709         gboolean result = FALSE;
 710         GeeMap* _tmp0_;
 711         gboolean _tmp1_ = FALSE;
 712         g_return_val_if_fail (map != NULL, FALSE);
 713         _tmp0_ = map;
 714         _tmp1_ = gee_map_has_all (self, _tmp0_);
 715         result = _tmp1_;
 716         return result;
 717 }
 718
 719
 720 /**
 721  * Returns an immutable empty map.
 722  *
 723  * @return an immutable empty map
 724  */
 725 GeeMap* gee_map_empty (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func) {
 726         GeeMap* result = NULL;
 727         GeeHashMap* _tmp0_;
 728         GeeHashMap* _tmp1_;
 729         GeeMap* _tmp2_;
 730         GeeMap* _tmp3_;
 731         GeeMap* _tmp4_;
 732         _tmp0_ = gee_hash_map_new (k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 733         _tmp1_ = _tmp0_;
 734         _tmp2_ = gee_abstract_map_get_read_only_view ((GeeAbstractMap*) _tmp1_);
 735         _tmp3_ = _tmp2_;
 736         _tmp4_ = _tmp3_;
 737         _g_object_unref0 (_tmp1_);
 738         result = _tmp4_;
 739         return result;
 740 }
 741
 742
 743 gint gee_map_get_size (GeeMap* self) {
 744         g_return_val_if_fail (self != NULL, 0);
 745         return GEE_MAP_GET_INTERFACE (self)->get_size (self);
 746 }
 747
 748
 749 gboolean gee_map_get_is_empty (GeeMap* self) {
 750         g_return_val_if_fail (self != NULL, FALSE);
 751         return GEE_MAP_GET_INTERFACE (self)->get_is_empty (self);
 752 }
 753
 754
 755 static gboolean gee_map_real_get_is_empty (GeeMap* base) {
 756         gboolean result;
 757         GeeMap* self;
 758         gint _tmp0_;
 759         gint _tmp1_;
 760         self = base;
 761         _tmp0_ = gee_map_get_size (self);
 762         _tmp1_ = _tmp0_;
 763         result = _tmp1_ == 0;
 764         return result;
 765 }
 766
 767
 768 gboolean gee_map_get_read_only (GeeMap* self) {
 769         g_return_val_if_fail (self != NULL, FALSE);
 770         return GEE_MAP_GET_INTERFACE (self)->get_read_only (self);
 771 }
 772
 773
 774 GeeSet* gee_map_get_keys (GeeMap* self) {
 775         g_return_val_if_fail (self != NULL, NULL);
 776         return GEE_MAP_GET_INTERFACE (self)->get_keys (self);
 777 }
 778
 779
 780 GeeCollection* gee_map_get_values (GeeMap* self) {
 781         g_return_val_if_fail (self != NULL, NULL);
 782         return GEE_MAP_GET_INTERFACE (self)->get_values (self);
 783 }
 784
 785
 786 GeeSet* gee_map_get_entries (GeeMap* self) {
 787         g_return_val_if_fail (self != NULL, NULL);
 788         return GEE_MAP_GET_INTERFACE (self)->get_entries (self);
 789 }
 790
 791
 792 GeeMap* gee_map_get_read_only_view (GeeMap* self) {
 793         g_return_val_if_fail (self != NULL, NULL);
 794         return GEE_MAP_GET_INTERFACE (self)->get_read_only_view (self);
 795 }
 796
 797
 798 GType gee_map_get_key_type (GeeMap* self) {
 799         GType result;
 800         g_return_val_if_fail (self != NULL, 0UL);
 801         result = GEE_MAP_GET_INTERFACE (self)->get_k_type (self);
 802         return result;
 803 }
 804
 805
 806 GType gee_map_get_value_type (GeeMap* self) {
 807         GType result;
 808         g_return_val_if_fail (self != NULL, 0UL);
 809         result = GEE_MAP_GET_INTERFACE (self)->get_v_type (self);
 810         return result;
 811 }
 812
 813
 814 GeeMapEntry* gee_map_entry_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func) {
 815         GeeMapEntry * self = NULL;
 816         self = (GeeMapEntry*) g_object_new (object_type, NULL);
 817         self->priv->k_type = k_type;
 818         self->priv->k_dup_func = k_dup_func;
 819         self->priv->k_destroy_func = k_destroy_func;
 820         self->priv->v_type = v_type;
 821         self->priv->v_dup_func = v_dup_func;
 822         self->priv->v_destroy_func = v_destroy_func;
 823         return self;
 824 }
 825
 826
 827 gconstpointer gee_map_entry_get_key (GeeMapEntry* self) {
 828         g_return_val_if_fail (self != NULL, NULL);
 829         return GEE_MAP_ENTRY_GET_CLASS (self)->get_key (self);
 830 }
 831
 832
 833 gconstpointer gee_map_entry_get_value (GeeMapEntry* self) {
 834         g_return_val_if_fail (self != NULL, NULL);
 835         return GEE_MAP_ENTRY_GET_CLASS (self)->get_value (self);
 836 }
 837
 838
 839 void gee_map_entry_set_value (GeeMapEntry* self, gconstpointer value) {
 840         g_return_if_fail (self != NULL);
 841         GEE_MAP_ENTRY_GET_CLASS (self)->set_value (self, value);
 842 }
 843
 844
 845 gboolean gee_map_entry_get_read_only (GeeMapEntry* self) {
 846         g_return_val_if_fail (self != NULL, FALSE);
 847         return GEE_MAP_ENTRY_GET_CLASS (self)->get_read_only (self);
 848 }
 849
 850
 851 static void gee_map_entry_class_init (GeeMapEntryClass * klass) {
 852         gee_map_entry_parent_class = g_type_class_peek_parent (klass);
 853         g_type_class_add_private (klass, sizeof (GeeMapEntryPrivate));
 854         G_OBJECT_CLASS (klass)->get_property = _vala_gee_map_entry_get_property;
 855         G_OBJECT_CLASS (klass)->set_property = _vala_gee_map_entry_set_property;
 856         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_K_TYPE, g_param_spec_gtype ("k-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 857         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_K_DUP_FUNC, g_param_spec_pointer ("k-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 858         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_K_DESTROY_FUNC, g_param_spec_pointer ("k-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 859         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_V_TYPE, g_param_spec_gtype ("v-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 860         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_V_DUP_FUNC, g_param_spec_pointer ("v-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 861         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_V_DESTROY_FUNC, g_param_spec_pointer ("v-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 862         /**
 863          * The key of this entry.
 864          */
 865         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_KEY, g_param_spec_pointer ("key", "key", "key", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 866         /**
 867          * The value of this entry.
 868          */
 869         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_VALUE, g_param_spec_pointer ("value", "value", "value", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 870         /**
 871          * ``true`` if the setting value is permitted.
 872          */
 873         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_MAP_ENTRY_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 874 }
 875
 876
 877 static void gee_map_entry_instance_init (GeeMapEntry * self) {
 878         self->priv = GEE_MAP_ENTRY_GET_PRIVATE (self);
 879 }
 880
 881
 882 /**
 883  * An entry of a map.
 884  */
 885 GType gee_map_entry_get_type (void) {
 886         static volatile gsize gee_map_entry_type_id__volatile = 0;
 887         if (g_once_init_enter (&gee_map_entry_type_id__volatile)) {
 888                 static const GTypeInfo g_define_type_info = { sizeof (GeeMapEntryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_map_entry_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeMapEntry), 0, (GInstanceInitFunc) gee_map_entry_instance_init, NULL };
 889                 GType gee_map_entry_type_id;
 890                 gee_map_entry_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeMapEntry", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
 891                 g_once_init_leave (&gee_map_entry_type_id__volatile, gee_map_entry_type_id);
 892         }
 893         return gee_map_entry_type_id__volatile;
 894 }
 895
 896
 897 static void _vala_gee_map_entry_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 898         GeeMapEntry * self;
 899         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_MAP_TYPE_ENTRY, GeeMapEntry);
 900         switch (property_id) {
 901                 default:
 902                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 903                 break;
 904         }
 905 }
 906
 907
 908 static void _vala_gee_map_entry_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 909         GeeMapEntry * self;
 910         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_MAP_TYPE_ENTRY, GeeMapEntry);
 911         switch (property_id) {
 912                 case GEE_MAP_ENTRY_K_TYPE:
 913                 self->priv->k_type = g_value_get_gtype (value);
 914                 break;
 915                 case GEE_MAP_ENTRY_K_DUP_FUNC:
 916                 self->priv->k_dup_func = g_value_get_pointer (value);
 917                 break;
 918                 case GEE_MAP_ENTRY_K_DESTROY_FUNC:
 919                 self->priv->k_destroy_func = g_value_get_pointer (value);
 920                 break;
 921                 case GEE_MAP_ENTRY_V_TYPE:
 922                 self->priv->v_type = g_value_get_gtype (value);
 923                 break;
 924                 case GEE_MAP_ENTRY_V_DUP_FUNC:
 925                 self->priv->v_dup_func = g_value_get_pointer (value);
 926                 break;
 927                 case GEE_MAP_ENTRY_V_DESTROY_FUNC:
 928                 self->priv->v_destroy_func = g_value_get_pointer (value);
 929                 break;
 930                 default:
 931                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 932                 break;
 933         }
 934 }
 935
 936
 937 static void gee_map_base_init (GeeMapIface * iface) {
 938         static gboolean initialized = FALSE;
 939         if (!initialized) {
 940                 initialized = TRUE;
 941                 /**
 942                  * The number of items in this map.
 943                  */
 944                 g_object_interface_install_property (iface, 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));
 945                 /**
 946                  * Specifies whether this collection can change - i.e. wheather {@link set},
 947                  * {@link remove} etc. are legal operations.
 948                  */
 949                 g_object_interface_install_property (iface, 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));
 950                 /**
 951                  * The read-only view of the keys of this map.
 952                  */
 953                 g_object_interface_install_property (iface, 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));
 954                 /**
 955                  * The read-only view of the values of this map.
 956                  */
 957                 g_object_interface_install_property (iface, 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));
 958                 /**
 959                  * The read-only view of the entries of this map.
 960                  */
 961                 g_object_interface_install_property (iface, 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));
 962                 /**
 963                  * The read-only view this map.
 964                  */
 965                 g_object_interface_install_property (iface, 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));
 966                 iface->set_all = gee_map_real_set_all;
 967                 iface->unset_all = gee_map_real_unset_all;
 968                 iface->has_all = gee_map_real_has_all;
 969                 iface->get_is_empty = gee_map_real_get_is_empty;
 970         }
 971 }
 972
 973
 974 /**
 975  * An object that maps keys to values.
 976  */
 977 GType gee_map_get_type (void) {
 978         static volatile gsize gee_map_type_id__volatile = 0;
 979         if (g_once_init_enter (&gee_map_type_id__volatile)) {
 980                 static const GTypeInfo g_define_type_info = { sizeof (GeeMapIface), (GBaseInitFunc) gee_map_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
 981                 GType gee_map_type_id;
 982                 gee_map_type_id = g_type_register_static (G_TYPE_INTERFACE, "GeeMap", &g_define_type_info, 0);
 983                 g_type_interface_add_prerequisite (gee_map_type_id, G_TYPE_OBJECT);
 984                 g_type_interface_add_prerequisite (gee_map_type_id, GEE_TYPE_ITERABLE);
 985                 g_once_init_leave (&gee_map_type_id__volatile, gee_map_type_id);
 986         }
 987         return gee_map_type_id__volatile;
 988 }
 989
 990
 991