gee/abstractmultiset.c

   1 /* abstractmultiset.c generated by valac 0.18.0, the Vala compiler
   2  * generated from abstractmultiset.vala, do not modify */
   3
   4 /* abstractmultiset.vala
   5  *
   6  * Copyright (C) 2009  Ali Sabil
   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  *      Ali Sabil <ali.sabil@gmail.com>
  24  *      Didier 'Ptitjes Villevalois <ptitjes@free.fr>
  25  */
  26
  27 #include <glib.h>
  28 #include <glib-object.h>
  29
  30
  31 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  32 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  33 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  34 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  35
  36 typedef struct _GeeTraversable GeeTraversable;
  37 typedef struct _GeeTraversableIface GeeTraversableIface;
  38
  39 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  40
  41 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  42 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  43 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  44 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  45 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  46 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  47
  48 typedef struct _GeeLazy GeeLazy;
  49 typedef struct _GeeLazyClass GeeLazyClass;
  50
  51 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  52 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  53 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  54 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  55
  56 typedef struct _GeeIterator GeeIterator;
  57 typedef struct _GeeIteratorIface GeeIteratorIface;
  58
  59 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  60 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  61 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  62 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  63
  64 typedef struct _GeeIterable GeeIterable;
  65 typedef struct _GeeIterableIface GeeIterableIface;
  66
  67 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  68 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  69 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  70 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  71
  72 typedef struct _GeeCollection GeeCollection;
  73 typedef struct _GeeCollectionIface GeeCollectionIface;
  74
  75 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
  76 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
  77 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  78 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
  79 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
  80 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  81
  82 typedef struct _GeeAbstractCollection GeeAbstractCollection;
  83 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
  84 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
  85
  86 #define GEE_TYPE_MULTI_SET (gee_multi_set_get_type ())
  87 #define GEE_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MULTI_SET, GeeMultiSet))
  88 #define GEE_IS_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MULTI_SET))
  89 #define GEE_MULTI_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MULTI_SET, GeeMultiSetIface))
  90
  91 typedef struct _GeeMultiSet GeeMultiSet;
  92 typedef struct _GeeMultiSetIface GeeMultiSetIface;
  93
  94 #define GEE_TYPE_ABSTRACT_MULTI_SET (gee_abstract_multi_set_get_type ())
  95 #define GEE_ABSTRACT_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_MULTI_SET, GeeAbstractMultiSet))
  96 #define GEE_ABSTRACT_MULTI_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_MULTI_SET, GeeAbstractMultiSetClass))
  97 #define GEE_IS_ABSTRACT_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_MULTI_SET))
  98 #define GEE_IS_ABSTRACT_MULTI_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_MULTI_SET))
  99 #define GEE_ABSTRACT_MULTI_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_MULTI_SET, GeeAbstractMultiSetClass))
 100
 101 typedef struct _GeeAbstractMultiSet GeeAbstractMultiSet;
 102 typedef struct _GeeAbstractMultiSetClass GeeAbstractMultiSetClass;
 103 typedef struct _GeeAbstractMultiSetPrivate GeeAbstractMultiSetPrivate;
 104
 105 #define GEE_TYPE_MAP (gee_map_get_type ())
 106 #define GEE_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP, GeeMap))
 107 #define GEE_IS_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP))
 108 #define GEE_MAP_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP, GeeMapIface))
 109
 110 typedef struct _GeeMap GeeMap;
 111 typedef struct _GeeMapIface GeeMapIface;
 112
 113 #define GEE_TYPE_MAP_ITERATOR (gee_map_iterator_get_type ())
 114 #define GEE_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIterator))
 115 #define GEE_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP_ITERATOR))
 116 #define GEE_MAP_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIteratorIface))
 117
 118 typedef struct _GeeMapIterator GeeMapIterator;
 119 typedef struct _GeeMapIteratorIface GeeMapIteratorIface;
 120
 121 #define GEE_TYPE_SET (gee_set_get_type ())
 122 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
 123 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
 124 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
 125
 126 typedef struct _GeeSet GeeSet;
 127 typedef struct _GeeSetIface GeeSetIface;
 128
 129 #define GEE_MAP_TYPE_ENTRY (gee_map_entry_get_type ())
 130 #define GEE_MAP_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntry))
 131 #define GEE_MAP_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 132 #define GEE_MAP_IS_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_MAP_TYPE_ENTRY))
 133 #define GEE_MAP_IS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_MAP_TYPE_ENTRY))
 134 #define GEE_MAP_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 135
 136 typedef struct _GeeMapEntry GeeMapEntry;
 137 typedef struct _GeeMapEntryClass GeeMapEntryClass;
 138 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 139
 140 #define GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR (gee_abstract_multi_set_iterator_get_type ())
 141 #define GEE_ABSTRACT_MULTI_SET_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, GeeAbstractMultiSetIterator))
 142 #define GEE_ABSTRACT_MULTI_SET_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, GeeAbstractMultiSetIteratorClass))
 143 #define GEE_ABSTRACT_MULTI_SET_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR))
 144 #define GEE_ABSTRACT_MULTI_SET_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR))
 145 #define GEE_ABSTRACT_MULTI_SET_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, GeeAbstractMultiSetIteratorClass))
 146
 147 typedef struct _GeeAbstractMultiSetIterator GeeAbstractMultiSetIterator;
 148 typedef struct _GeeAbstractMultiSetIteratorClass GeeAbstractMultiSetIteratorClass;
 149
 150 #define GEE_TYPE_READ_ONLY_COLLECTION (gee_read_only_collection_get_type ())
 151 #define GEE_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection))
 152 #define GEE_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
 153 #define GEE_IS_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_COLLECTION))
 154 #define GEE_IS_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_COLLECTION))
 155 #define GEE_READ_ONLY_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
 156
 157 typedef struct _GeeReadOnlyCollection GeeReadOnlyCollection;
 158 typedef struct _GeeReadOnlyCollectionClass GeeReadOnlyCollectionClass;
 159
 160 #define GEE_TYPE_READ_ONLY_MULTI_SET (gee_read_only_multi_set_get_type ())
 161 #define GEE_READ_ONLY_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_MULTI_SET, GeeReadOnlyMultiSet))
 162 #define GEE_READ_ONLY_MULTI_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_MULTI_SET, GeeReadOnlyMultiSetClass))
 163 #define GEE_IS_READ_ONLY_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_MULTI_SET))
 164 #define GEE_IS_READ_ONLY_MULTI_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_MULTI_SET))
 165 #define GEE_READ_ONLY_MULTI_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_MULTI_SET, GeeReadOnlyMultiSetClass))
 166
 167 typedef struct _GeeReadOnlyMultiSet GeeReadOnlyMultiSet;
 168 typedef struct _GeeReadOnlyMultiSetClass GeeReadOnlyMultiSetClass;
 169 typedef struct _GeeAbstractMultiSetIteratorPrivate GeeAbstractMultiSetIteratorPrivate;
 170 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 171
 172 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 173 typedef enum  {
 174         GEE_TRAVERSABLE_STREAM_YIELD,
 175         GEE_TRAVERSABLE_STREAM_CONTINUE,
 176         GEE_TRAVERSABLE_STREAM_END
 177 } GeeTraversableStream;
 178
 179 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 180 struct _GeeIteratorIface {
 181         GTypeInterface parent_iface;
 182         gboolean (*next) (GeeIterator* self);
 183         gboolean (*has_next) (GeeIterator* self);
 184         gpointer (*get) (GeeIterator* self);
 185         void (*remove) (GeeIterator* self);
 186         gboolean (*get_valid) (GeeIterator* self);
 187         gboolean (*get_read_only) (GeeIterator* self);
 188 };
 189
 190 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 191 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 192 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 193 struct _GeeTraversableIface {
 194         GTypeInterface parent_iface;
 195         GType (*get_g_type) (GeeTraversable* self);
 196         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 197         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 198         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 199         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);
 200         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 201         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 202         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 203         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 204         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 205         GType (*get_element_type) (GeeTraversable* self);
 206 };
 207
 208 struct _GeeIterableIface {
 209         GTypeInterface parent_iface;
 210         GType (*get_g_type) (GeeIterable* self);
 211         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 212         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 213         GeeIterator* (*iterator) (GeeIterable* self);
 214 };
 215
 216 struct _GeeCollectionIface {
 217         GTypeInterface parent_iface;
 218         GType (*get_g_type) (GeeCollection* self);
 219         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 220         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 221         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 222         gboolean (*add) (GeeCollection* self, gconstpointer item);
 223         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 224         void (*clear) (GeeCollection* self);
 225         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 226         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 227         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 228         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 229         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 230         gint (*get_size) (GeeCollection* self);
 231         gboolean (*get_is_empty) (GeeCollection* self);
 232         gboolean (*get_read_only) (GeeCollection* self);
 233         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 234 };
 235
 236 struct _GeeAbstractCollection {
 237         GObject parent_instance;
 238         GeeAbstractCollectionPrivate * priv;
 239 };
 240
 241 struct _GeeAbstractCollectionClass {
 242         GObjectClass parent_class;
 243         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 244         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 245         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 246         void (*clear) (GeeAbstractCollection* self);
 247         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 248         gboolean (*foreach) (GeeAbstractCollection* self, GeeForallFunc f, void* f_target);
 249         void (*reserved0) (GeeAbstractCollection* self);
 250         void (*reserved1) (GeeAbstractCollection* self);
 251         void (*reserved2) (GeeAbstractCollection* self);
 252         void (*reserved3) (GeeAbstractCollection* self);
 253         void (*reserved4) (GeeAbstractCollection* self);
 254         void (*reserved5) (GeeAbstractCollection* self);
 255         void (*reserved6) (GeeAbstractCollection* self);
 256         void (*reserved7) (GeeAbstractCollection* self);
 257         void (*reserved8) (GeeAbstractCollection* self);
 258         void (*reserved9) (GeeAbstractCollection* self);
 259         gint (*get_size) (GeeAbstractCollection* self);
 260         gboolean (*get_read_only) (GeeAbstractCollection* self);
 261         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 262 };
 263
 264 struct _GeeMultiSetIface {
 265         GTypeInterface parent_iface;
 266         GType (*get_g_type) (GeeMultiSet* self);
 267         GBoxedCopyFunc (*get_g_dup_func) (GeeMultiSet* self);
 268         GDestroyNotify (*get_g_destroy_func) (GeeMultiSet* self);
 269         gint (*count) (GeeMultiSet* self, gconstpointer item);
 270         GeeMultiSet* (*get_read_only_view) (GeeMultiSet* self);
 271 };
 272
 273 typedef gpointer (*GeeFoldMapFunc) (gconstpointer k, gconstpointer v, gpointer a, void* user_data);
 274 typedef gboolean (*GeeForallMapFunc) (gconstpointer k, gconstpointer v, void* user_data);
 275 struct _GeeMapIteratorIface {
 276         GTypeInterface parent_iface;
 277         GType (*get_k_type) (GeeMapIterator* self);
 278         GBoxedCopyFunc (*get_k_dup_func) (GeeMapIterator* self);
 279         GDestroyNotify (*get_k_destroy_func) (GeeMapIterator* self);
 280         GType (*get_v_type) (GeeMapIterator* self);
 281         GBoxedCopyFunc (*get_v_dup_func) (GeeMapIterator* self);
 282         GDestroyNotify (*get_v_destroy_func) (GeeMapIterator* self);
 283         gboolean (*next) (GeeMapIterator* self);
 284         gboolean (*has_next) (GeeMapIterator* self);
 285         gpointer (*get_key) (GeeMapIterator* self);
 286         gpointer (*get_value) (GeeMapIterator* self);
 287         void (*set_value) (GeeMapIterator* self, gconstpointer value);
 288         void (*unset) (GeeMapIterator* self);
 289         gpointer (*fold) (GeeMapIterator* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldMapFunc f, void* f_target, gpointer seed);
 290         gboolean (*foreach) (GeeMapIterator* self, GeeForallMapFunc f, void* f_target);
 291         gboolean (*get_valid) (GeeMapIterator* self);
 292         gboolean (*get_mutable) (GeeMapIterator* self);
 293         gboolean (*get_read_only) (GeeMapIterator* self);
 294 };
 295
 296 struct _GeeSetIface {
 297         GTypeInterface parent_iface;
 298         GType (*get_g_type) (GeeSet* self);
 299         GBoxedCopyFunc (*get_g_dup_func) (GeeSet* self);
 300         GDestroyNotify (*get_g_destroy_func) (GeeSet* self);
 301         GeeSet* (*get_read_only_view) (GeeSet* self);
 302 };
 303
 304 struct _GeeMapIface {
 305         GTypeInterface parent_iface;
 306         GType (*get_k_type) (GeeMap* self);
 307         GBoxedCopyFunc (*get_k_dup_func) (GeeMap* self);
 308         GDestroyNotify (*get_k_destroy_func) (GeeMap* self);
 309         GType (*get_v_type) (GeeMap* self);
 310         GBoxedCopyFunc (*get_v_dup_func) (GeeMap* self);
 311         GDestroyNotify (*get_v_destroy_func) (GeeMap* self);
 312         gboolean (*has_key) (GeeMap* self, gconstpointer key);
 313         gboolean (*has) (GeeMap* self, gconstpointer key, gconstpointer value);
 314         gpointer (*get) (GeeMap* self, gconstpointer key);
 315         void (*set) (GeeMap* self, gconstpointer key, gconstpointer value);
 316         gboolean (*unset) (GeeMap* self, gconstpointer key, gpointer* value);
 317         void (*clear) (GeeMap* self);
 318         GeeMapIterator* (*map_iterator) (GeeMap* self);
 319         void (*set_all) (GeeMap* self, GeeMap* map);
 320         gboolean (*unset_all) (GeeMap* self, GeeMap* map);
 321         gboolean (*has_all) (GeeMap* self, GeeMap* map);
 322         gint (*get_size) (GeeMap* self);
 323         gboolean (*get_is_empty) (GeeMap* self);
 324         gboolean (*get_read_only) (GeeMap* self);
 325         GeeSet* (*get_keys) (GeeMap* self);
 326         GeeCollection* (*get_values) (GeeMap* self);
 327         GeeSet* (*get_entries) (GeeMap* self);
 328         GeeMap* (*get_read_only_view) (GeeMap* self);
 329 };
 330
 331 struct _GeeAbstractMultiSet {
 332         GeeAbstractCollection parent_instance;
 333         GeeAbstractMultiSetPrivate * priv;
 334         GeeMap* _storage_map;
 335 };
 336
 337 struct _GeeAbstractMultiSetClass {
 338         GeeAbstractCollectionClass parent_class;
 339         void (*reserved0) (GeeAbstractMultiSet* self);
 340         void (*reserved1) (GeeAbstractMultiSet* self);
 341         void (*reserved2) (GeeAbstractMultiSet* self);
 342         void (*reserved3) (GeeAbstractMultiSet* self);
 343         void (*reserved4) (GeeAbstractMultiSet* self);
 344         void (*reserved5) (GeeAbstractMultiSet* self);
 345         void (*reserved6) (GeeAbstractMultiSet* self);
 346         void (*reserved7) (GeeAbstractMultiSet* self);
 347         void (*reserved8) (GeeAbstractMultiSet* self);
 348         GeeMultiSet* (*get_read_only_view) (GeeAbstractMultiSet* self);
 349 };
 350
 351 struct _GeeAbstractMultiSetPrivate {
 352         GType g_type;
 353         GBoxedCopyFunc g_dup_func;
 354         GDestroyNotify g_destroy_func;
 355         gint _nitems;
 356         GeeMultiSet* _read_only_view;
 357 };
 358
 359 struct _GeeAbstractMultiSetIterator {
 360         GObject parent_instance;
 361         GeeAbstractMultiSetIteratorPrivate * priv;
 362 };
 363
 364 struct _GeeAbstractMultiSetIteratorClass {
 365         GObjectClass parent_class;
 366 };
 367
 368 struct _GeeAbstractMultiSetIteratorPrivate {
 369         GType g_type;
 370         GBoxedCopyFunc g_dup_func;
 371         GDestroyNotify g_destroy_func;
 372         GeeAbstractMultiSet* _set;
 373         GeeMapIterator* _iter;
 374         gint _pending;
 375         gboolean _removed;
 376 };
 377
 378
 379 static gpointer gee_abstract_multi_set_parent_class = NULL;
 380 static gpointer gee_abstract_multi_set_iterator_parent_class = NULL;
 381 static GeeTraversableIface* gee_abstract_multi_set_iterator_gee_traversable_parent_iface = NULL;
 382 static GeeIteratorIface* gee_abstract_multi_set_iterator_gee_iterator_parent_iface = NULL;
 383 static GeeMultiSetIface* gee_abstract_multi_set_gee_multi_set_parent_iface = NULL;
 384
 385 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 386 gpointer gee_lazy_ref (gpointer instance);
 387 void gee_lazy_unref (gpointer instance);
 388 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 389 void gee_value_set_lazy (GValue* value, gpointer v_object);
 390 void gee_value_take_lazy (GValue* value, gpointer v_object);
 391 gpointer gee_value_get_lazy (const GValue* value);
 392 GType gee_lazy_get_type (void) G_GNUC_CONST;
 393 GType gee_iterator_get_type (void) G_GNUC_CONST;
 394 GType gee_traversable_get_type (void) G_GNUC_CONST;
 395 GType gee_iterable_get_type (void) G_GNUC_CONST;
 396 GType gee_collection_get_type (void) G_GNUC_CONST;
 397 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 398 GType gee_multi_set_get_type (void) G_GNUC_CONST;
 399 GType gee_abstract_multi_set_get_type (void) G_GNUC_CONST;
 400 GType gee_map_iterator_get_type (void) G_GNUC_CONST;
 401 GType gee_set_get_type (void) G_GNUC_CONST;
 402 GType gee_map_entry_get_type (void) G_GNUC_CONST;
 403 GType gee_map_get_type (void) G_GNUC_CONST;
 404 #define GEE_ABSTRACT_MULTI_SET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_ABSTRACT_MULTI_SET, GeeAbstractMultiSetPrivate))
 405 enum  {
 406         GEE_ABSTRACT_MULTI_SET_DUMMY_PROPERTY,
 407         GEE_ABSTRACT_MULTI_SET_G_TYPE,
 408         GEE_ABSTRACT_MULTI_SET_G_DUP_FUNC,
 409         GEE_ABSTRACT_MULTI_SET_G_DESTROY_FUNC,
 410         GEE_ABSTRACT_MULTI_SET_SIZE,
 411         GEE_ABSTRACT_MULTI_SET_READ_ONLY
 412 };
 413 GeeAbstractMultiSet* gee_abstract_multi_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeMap* storage_map);
 414 GeeAbstractCollection* gee_abstract_collection_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 415 static gint gee_abstract_multi_set_real_count (GeeMultiSet* base, gconstpointer item);
 416 gboolean gee_map_has_key (GeeMap* self, gconstpointer key);
 417 gpointer gee_map_get (GeeMap* self, gconstpointer key);
 418 static gboolean gee_abstract_multi_set_real_contains (GeeAbstractCollection* base, gconstpointer item);
 419 static GeeIterator* gee_abstract_multi_set_real_iterator (GeeAbstractCollection* base);
 420 static GeeAbstractMultiSetIterator* gee_abstract_multi_set_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeAbstractMultiSet* set);
 421 static GeeAbstractMultiSetIterator* gee_abstract_multi_set_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeAbstractMultiSet* set);
 422 static GType gee_abstract_multi_set_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 423 static gboolean gee_abstract_multi_set_real_add (GeeAbstractCollection* base, gconstpointer item);
 424 void gee_map_set (GeeMap* self, gconstpointer key, gconstpointer value);
 425 static gboolean gee_abstract_multi_set_real_remove (GeeAbstractCollection* base, gconstpointer item);
 426 gboolean gee_map_unset (GeeMap* self, gconstpointer key, gpointer* value);
 427 static void gee_abstract_multi_set_real_clear (GeeAbstractCollection* base);
 428 void gee_map_clear (GeeMap* self);
 429 void gee_abstract_multi_set_reserved0 (GeeAbstractMultiSet* self);
 430 static void gee_abstract_multi_set_real_reserved0 (GeeAbstractMultiSet* self);
 431 void gee_abstract_multi_set_reserved1 (GeeAbstractMultiSet* self);
 432 static void gee_abstract_multi_set_real_reserved1 (GeeAbstractMultiSet* self);
 433 void gee_abstract_multi_set_reserved2 (GeeAbstractMultiSet* self);
 434 static void gee_abstract_multi_set_real_reserved2 (GeeAbstractMultiSet* self);
 435 void gee_abstract_multi_set_reserved3 (GeeAbstractMultiSet* self);
 436 static void gee_abstract_multi_set_real_reserved3 (GeeAbstractMultiSet* self);
 437 void gee_abstract_multi_set_reserved4 (GeeAbstractMultiSet* self);
 438 static void gee_abstract_multi_set_real_reserved4 (GeeAbstractMultiSet* self);
 439 void gee_abstract_multi_set_reserved5 (GeeAbstractMultiSet* self);
 440 static void gee_abstract_multi_set_real_reserved5 (GeeAbstractMultiSet* self);
 441 void gee_abstract_multi_set_reserved6 (GeeAbstractMultiSet* self);
 442 static void gee_abstract_multi_set_real_reserved6 (GeeAbstractMultiSet* self);
 443 void gee_abstract_multi_set_reserved7 (GeeAbstractMultiSet* self);
 444 static void gee_abstract_multi_set_real_reserved7 (GeeAbstractMultiSet* self);
 445 void gee_abstract_multi_set_reserved8 (GeeAbstractMultiSet* self);
 446 static void gee_abstract_multi_set_real_reserved8 (GeeAbstractMultiSet* self);
 447 GeeMultiSet* gee_abstract_multi_set_get_read_only_view (GeeAbstractMultiSet* self);
 448 GeeReadOnlyMultiSet* gee_read_only_multi_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeMultiSet* multiset);
 449 GeeReadOnlyMultiSet* gee_read_only_multi_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeMultiSet* multiset);
 450 GType gee_read_only_collection_get_type (void) G_GNUC_CONST;
 451 GType gee_read_only_multi_set_get_type (void) G_GNUC_CONST;
 452 #define GEE_ABSTRACT_MULTI_SET_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, GeeAbstractMultiSetIteratorPrivate))
 453 enum  {
 454         GEE_ABSTRACT_MULTI_SET_ITERATOR_DUMMY_PROPERTY,
 455         GEE_ABSTRACT_MULTI_SET_ITERATOR_G_TYPE,
 456         GEE_ABSTRACT_MULTI_SET_ITERATOR_G_DUP_FUNC,
 457         GEE_ABSTRACT_MULTI_SET_ITERATOR_G_DESTROY_FUNC,
 458         GEE_ABSTRACT_MULTI_SET_ITERATOR_READ_ONLY,
 459         GEE_ABSTRACT_MULTI_SET_ITERATOR_VALID
 460 };
 461 GeeMapIterator* gee_map_map_iterator (GeeMap* self);
 462 static gboolean gee_abstract_multi_set_iterator_real_next (GeeIterator* base);
 463 gboolean gee_map_iterator_next (GeeMapIterator* self);
 464 gpointer gee_map_iterator_get_value (GeeMapIterator* self);
 465 static gboolean gee_abstract_multi_set_iterator_real_has_next (GeeIterator* base);
 466 gboolean gee_map_iterator_has_next (GeeMapIterator* self);
 467 static gpointer gee_abstract_multi_set_iterator_real_get (GeeIterator* base);
 468 gpointer gee_map_iterator_get_key (GeeMapIterator* self);
 469 static void gee_abstract_multi_set_iterator_real_remove (GeeIterator* base);
 470 void gee_map_iterator_set_value (GeeMapIterator* self, gconstpointer value);
 471 void gee_map_iterator_unset (GeeMapIterator* self);
 472 static gboolean gee_abstract_multi_set_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 473 gboolean gee_map_iterator_get_valid (GeeMapIterator* self);
 474 static void gee_abstract_multi_set_iterator_finalize (GObject* obj);
 475 gboolean gee_iterator_get_read_only (GeeIterator* self);
 476 gboolean gee_iterator_get_valid (GeeIterator* self);
 477 static void _vala_gee_abstract_multi_set_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 478 static void _vala_gee_abstract_multi_set_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 479 static void gee_abstract_multi_set_finalize (GObject* obj);
 480 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 481 gboolean gee_abstract_collection_get_read_only (GeeAbstractCollection* self);
 482 static void _vala_gee_abstract_multi_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 483 static void _vala_gee_abstract_multi_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 484
 485
 486 /**
 487  * Constructs a new, empty abstract multi set.
 488  */
 489 static gpointer _g_object_ref0 (gpointer self) {
 490         return self ? g_object_ref (self) : NULL;
 491 }
 492
 493
 494 GeeAbstractMultiSet* gee_abstract_multi_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeMap* storage_map) {
 495         GeeAbstractMultiSet * self = NULL;
 496         GeeMap* _tmp0_;
 497         GeeMap* _tmp1_;
 498         g_return_val_if_fail (storage_map != NULL, NULL);
 499         self = (GeeAbstractMultiSet*) gee_abstract_collection_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
 500         self->priv->g_type = g_type;
 501         self->priv->g_dup_func = g_dup_func;
 502         self->priv->g_destroy_func = g_destroy_func;
 503         _tmp0_ = storage_map;
 504         _tmp1_ = _g_object_ref0 (_tmp0_);
 505         _g_object_unref0 (self->_storage_map);
 506         self->_storage_map = _tmp1_;
 507         return self;
 508 }
 509
 510
 511 static gint gee_abstract_multi_set_real_count (GeeMultiSet* base, gconstpointer item) {
 512         GeeAbstractMultiSet * self;
 513         gint result = 0;
 514         gint _result_;
 515         GeeMap* _tmp0_;
 516         gconstpointer _tmp1_;
 517         gboolean _tmp2_ = FALSE;
 518         self = (GeeAbstractMultiSet*) base;
 519         _result_ = 0;
 520         _tmp0_ = self->_storage_map;
 521         _tmp1_ = item;
 522         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
 523         if (_tmp2_) {
 524                 GeeMap* _tmp3_;
 525                 gconstpointer _tmp4_;
 526                 gpointer _tmp5_ = NULL;
 527                 _tmp3_ = self->_storage_map;
 528                 _tmp4_ = item;
 529                 _tmp5_ = gee_map_get (_tmp3_, _tmp4_);
 530                 _result_ = (gint) ((gintptr) _tmp5_);
 531         }
 532         result = _result_;
 533         return result;
 534 }
 535
 536
 537 static gboolean gee_abstract_multi_set_real_contains (GeeAbstractCollection* base, gconstpointer item) {
 538         GeeAbstractMultiSet * self;
 539         gboolean result = FALSE;
 540         GeeMap* _tmp0_;
 541         gconstpointer _tmp1_;
 542         gboolean _tmp2_ = FALSE;
 543         self = (GeeAbstractMultiSet*) base;
 544         _tmp0_ = self->_storage_map;
 545         _tmp1_ = item;
 546         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
 547         result = _tmp2_;
 548         return result;
 549 }
 550
 551
 552 static GeeIterator* gee_abstract_multi_set_real_iterator (GeeAbstractCollection* base) {
 553         GeeAbstractMultiSet * self;
 554         GeeIterator* result = NULL;
 555         GeeAbstractMultiSetIterator* _tmp0_;
 556         self = (GeeAbstractMultiSet*) base;
 557         _tmp0_ = gee_abstract_multi_set_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self);
 558         result = (GeeIterator*) _tmp0_;
 559         return result;
 560 }
 561
 562
 563 static gboolean gee_abstract_multi_set_real_add (GeeAbstractCollection* base, gconstpointer item) {
 564         GeeAbstractMultiSet * self;
 565         gboolean result = FALSE;
 566         GeeMap* _tmp0_;
 567         gconstpointer _tmp1_;
 568         gboolean _tmp2_ = FALSE;
 569         gint _tmp11_;
 570         self = (GeeAbstractMultiSet*) base;
 571         _tmp0_ = self->_storage_map;
 572         _tmp1_ = item;
 573         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
 574         if (_tmp2_) {
 575                 GeeMap* _tmp3_;
 576                 gconstpointer _tmp4_;
 577                 gpointer _tmp5_ = NULL;
 578                 gint current_count;
 579                 GeeMap* _tmp6_;
 580                 gconstpointer _tmp7_;
 581                 gint _tmp8_;
 582                 _tmp3_ = self->_storage_map;
 583                 _tmp4_ = item;
 584                 _tmp5_ = gee_map_get (_tmp3_, _tmp4_);
 585                 current_count = (gint) ((gintptr) _tmp5_);
 586                 _tmp6_ = self->_storage_map;
 587                 _tmp7_ = item;
 588                 _tmp8_ = current_count;
 589                 gee_map_set (_tmp6_, _tmp7_, (gpointer) ((gintptr) (_tmp8_ + 1)));
 590         } else {
 591                 GeeMap* _tmp9_;
 592                 gconstpointer _tmp10_;
 593                 _tmp9_ = self->_storage_map;
 594                 _tmp10_ = item;
 595                 gee_map_set (_tmp9_, _tmp10_, (gpointer) ((gintptr) 1));
 596         }
 597         _tmp11_ = self->priv->_nitems;
 598         self->priv->_nitems = _tmp11_ + 1;
 599         result = TRUE;
 600         return result;
 601 }
 602
 603
 604 static gboolean gee_abstract_multi_set_real_remove (GeeAbstractCollection* base, gconstpointer item) {
 605         GeeAbstractMultiSet * self;
 606         gboolean result = FALSE;
 607         gboolean _tmp0_ = FALSE;
 608         gint _tmp1_;
 609         gboolean _tmp5_;
 610         self = (GeeAbstractMultiSet*) base;
 611         _tmp1_ = self->priv->_nitems;
 612         if (_tmp1_ > 0) {
 613                 GeeMap* _tmp2_;
 614                 gconstpointer _tmp3_;
 615                 gboolean _tmp4_ = FALSE;
 616                 _tmp2_ = self->_storage_map;
 617                 _tmp3_ = item;
 618                 _tmp4_ = gee_map_has_key (_tmp2_, _tmp3_);
 619                 _tmp0_ = _tmp4_;
 620         } else {
 621                 _tmp0_ = FALSE;
 622         }
 623         _tmp5_ = _tmp0_;
 624         if (_tmp5_) {
 625                 GeeMap* _tmp6_;
 626                 gconstpointer _tmp7_;
 627                 gpointer _tmp8_ = NULL;
 628                 gint current_count;
 629                 gint _tmp9_;
 630                 gint _tmp15_;
 631                 _tmp6_ = self->_storage_map;
 632                 _tmp7_ = item;
 633                 _tmp8_ = gee_map_get (_tmp6_, _tmp7_);
 634                 current_count = (gint) ((gintptr) _tmp8_);
 635                 _tmp9_ = current_count;
 636                 if (_tmp9_ <= 1) {
 637                         GeeMap* _tmp10_;
 638                         gconstpointer _tmp11_;
 639                         _tmp10_ = self->_storage_map;
 640                         _tmp11_ = item;
 641                         gee_map_unset (_tmp10_, _tmp11_, NULL);
 642                 } else {
 643                         GeeMap* _tmp12_;
 644                         gconstpointer _tmp13_;
 645                         gint _tmp14_;
 646                         _tmp12_ = self->_storage_map;
 647                         _tmp13_ = item;
 648                         _tmp14_ = current_count;
 649                         gee_map_set (_tmp12_, _tmp13_, (gpointer) ((gintptr) (_tmp14_ - 1)));
 650                 }
 651                 _tmp15_ = self->priv->_nitems;
 652                 self->priv->_nitems = _tmp15_ - 1;
 653                 result = TRUE;
 654                 return result;
 655         }
 656         result = FALSE;
 657         return result;
 658 }
 659
 660
 661 static void gee_abstract_multi_set_real_clear (GeeAbstractCollection* base) {
 662         GeeAbstractMultiSet * self;
 663         GeeMap* _tmp0_;
 664         self = (GeeAbstractMultiSet*) base;
 665         _tmp0_ = self->_storage_map;
 666         gee_map_clear (_tmp0_);
 667         self->priv->_nitems = 0;
 668 }
 669
 670
 671 static void gee_abstract_multi_set_real_reserved0 (GeeAbstractMultiSet* self) {
 672 }
 673
 674
 675 void gee_abstract_multi_set_reserved0 (GeeAbstractMultiSet* self) {
 676         g_return_if_fail (self != NULL);
 677         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved0 (self);
 678 }
 679
 680
 681 static void gee_abstract_multi_set_real_reserved1 (GeeAbstractMultiSet* self) {
 682 }
 683
 684
 685 void gee_abstract_multi_set_reserved1 (GeeAbstractMultiSet* self) {
 686         g_return_if_fail (self != NULL);
 687         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved1 (self);
 688 }
 689
 690
 691 static void gee_abstract_multi_set_real_reserved2 (GeeAbstractMultiSet* self) {
 692 }
 693
 694
 695 void gee_abstract_multi_set_reserved2 (GeeAbstractMultiSet* self) {
 696         g_return_if_fail (self != NULL);
 697         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved2 (self);
 698 }
 699
 700
 701 static void gee_abstract_multi_set_real_reserved3 (GeeAbstractMultiSet* self) {
 702 }
 703
 704
 705 void gee_abstract_multi_set_reserved3 (GeeAbstractMultiSet* self) {
 706         g_return_if_fail (self != NULL);
 707         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved3 (self);
 708 }
 709
 710
 711 static void gee_abstract_multi_set_real_reserved4 (GeeAbstractMultiSet* self) {
 712 }
 713
 714
 715 void gee_abstract_multi_set_reserved4 (GeeAbstractMultiSet* self) {
 716         g_return_if_fail (self != NULL);
 717         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved4 (self);
 718 }
 719
 720
 721 static void gee_abstract_multi_set_real_reserved5 (GeeAbstractMultiSet* self) {
 722 }
 723
 724
 725 void gee_abstract_multi_set_reserved5 (GeeAbstractMultiSet* self) {
 726         g_return_if_fail (self != NULL);
 727         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved5 (self);
 728 }
 729
 730
 731 static void gee_abstract_multi_set_real_reserved6 (GeeAbstractMultiSet* self) {
 732 }
 733
 734
 735 void gee_abstract_multi_set_reserved6 (GeeAbstractMultiSet* self) {
 736         g_return_if_fail (self != NULL);
 737         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved6 (self);
 738 }
 739
 740
 741 static void gee_abstract_multi_set_real_reserved7 (GeeAbstractMultiSet* self) {
 742 }
 743
 744
 745 void gee_abstract_multi_set_reserved7 (GeeAbstractMultiSet* self) {
 746         g_return_if_fail (self != NULL);
 747         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved7 (self);
 748 }
 749
 750
 751 static void gee_abstract_multi_set_real_reserved8 (GeeAbstractMultiSet* self) {
 752 }
 753
 754
 755 void gee_abstract_multi_set_reserved8 (GeeAbstractMultiSet* self) {
 756         g_return_if_fail (self != NULL);
 757         GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->reserved8 (self);
 758 }
 759
 760
 761 static gint gee_abstract_multi_set_real_get_size (GeeAbstractCollection* base) {
 762         gint result;
 763         GeeAbstractMultiSet* self;
 764         gint _tmp0_;
 765         self = (GeeAbstractMultiSet*) base;
 766         _tmp0_ = self->priv->_nitems;
 767         result = _tmp0_;
 768         return result;
 769 }
 770
 771
 772 static gboolean gee_abstract_multi_set_real_get_read_only (GeeAbstractCollection* base) {
 773         gboolean result;
 774         GeeAbstractMultiSet* self;
 775         self = (GeeAbstractMultiSet*) base;
 776         result = FALSE;
 777         return result;
 778 }
 779
 780
 781 GeeMultiSet* gee_abstract_multi_set_get_read_only_view (GeeAbstractMultiSet* self) {
 782         g_return_val_if_fail (self != NULL, NULL);
 783         return GEE_ABSTRACT_MULTI_SET_GET_CLASS (self)->get_read_only_view (self);
 784 }
 785
 786
 787 static GeeMultiSet* gee_abstract_multi_set_real_get_read_only_view (GeeAbstractMultiSet* base) {
 788         GeeMultiSet* result;
 789         GeeAbstractMultiSet* self;
 790         GeeMultiSet* _tmp0_;
 791         GeeMultiSet* _tmp1_;
 792         GeeMultiSet* instance;
 793         GeeMultiSet* _tmp2_;
 794         self = base;
 795         _tmp0_ = self->priv->_read_only_view;
 796         _tmp1_ = _g_object_ref0 (_tmp0_);
 797         instance = _tmp1_;
 798         _tmp2_ = self->priv->_read_only_view;
 799         if (_tmp2_ == NULL) {
 800                 GeeReadOnlyMultiSet* _tmp3_;
 801                 GeeMultiSet* _tmp4_;
 802                 GeeMultiSet* _tmp5_;
 803                 _tmp3_ = gee_read_only_multi_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, (GeeMultiSet*) self);
 804                 _g_object_unref0 (instance);
 805                 instance = (GeeMultiSet*) _tmp3_;
 806                 _tmp4_ = instance;
 807                 self->priv->_read_only_view = _tmp4_;
 808                 _tmp5_ = instance;
 809                 g_object_add_weak_pointer ((GObject*) _tmp5_, (void**) (&self->priv->_read_only_view));
 810         }
 811         result = instance;
 812         return result;
 813 }
 814
 815
 816 static GeeAbstractMultiSetIterator* gee_abstract_multi_set_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeAbstractMultiSet* set) {
 817         GeeAbstractMultiSetIterator * self = NULL;
 818         GeeAbstractMultiSet* _tmp0_;
 819         GeeAbstractMultiSet* _tmp1_;
 820         GeeAbstractMultiSet* _tmp2_;
 821         GeeMap* _tmp3_;
 822         GeeMapIterator* _tmp4_ = NULL;
 823         g_return_val_if_fail (set != NULL, NULL);
 824         self = (GeeAbstractMultiSetIterator*) g_object_new (object_type, NULL);
 825         self->priv->g_type = g_type;
 826         self->priv->g_dup_func = g_dup_func;
 827         self->priv->g_destroy_func = g_destroy_func;
 828         _tmp0_ = set;
 829         _tmp1_ = _g_object_ref0 (_tmp0_);
 830         _g_object_unref0 (self->priv->_set);
 831         self->priv->_set = _tmp1_;
 832         _tmp2_ = self->priv->_set;
 833         _tmp3_ = _tmp2_->_storage_map;
 834         _tmp4_ = gee_map_map_iterator (_tmp3_);
 835         _g_object_unref0 (self->priv->_iter);
 836         self->priv->_iter = _tmp4_;
 837         return self;
 838 }
 839
 840
 841 static GeeAbstractMultiSetIterator* gee_abstract_multi_set_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeAbstractMultiSet* set) {
 842         return gee_abstract_multi_set_iterator_construct (GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, set);
 843 }
 844
 845
 846 static gboolean gee_abstract_multi_set_iterator_real_next (GeeIterator* base) {
 847         GeeAbstractMultiSetIterator * self;
 848         gboolean result = FALSE;
 849         gint _tmp0_;
 850         self = (GeeAbstractMultiSetIterator*) base;
 851         self->priv->_removed = FALSE;
 852         _tmp0_ = self->priv->_pending;
 853         if (_tmp0_ == 0) {
 854                 GeeMapIterator* _tmp1_;
 855                 gboolean _tmp2_ = FALSE;
 856                 _tmp1_ = self->priv->_iter;
 857                 _tmp2_ = gee_map_iterator_next (_tmp1_);
 858                 if (_tmp2_) {
 859                         GeeMapIterator* _tmp3_;
 860                         gpointer _tmp4_ = NULL;
 861                         _tmp3_ = self->priv->_iter;
 862                         _tmp4_ = gee_map_iterator_get_value (_tmp3_);
 863                         self->priv->_pending = ((gint) ((gintptr) _tmp4_)) - 1;
 864                         result = TRUE;
 865                         return result;
 866                 }
 867         } else {
 868                 gint _tmp5_;
 869                 _tmp5_ = self->priv->_pending;
 870                 self->priv->_pending = _tmp5_ - 1;
 871                 result = TRUE;
 872                 return result;
 873         }
 874         result = FALSE;
 875         return result;
 876 }
 877
 878
 879 static gboolean gee_abstract_multi_set_iterator_real_has_next (GeeIterator* base) {
 880         GeeAbstractMultiSetIterator * self;
 881         gboolean result = FALSE;
 882         gboolean _tmp0_ = FALSE;
 883         gint _tmp1_;
 884         gboolean _tmp4_;
 885         self = (GeeAbstractMultiSetIterator*) base;
 886         _tmp1_ = self->priv->_pending;
 887         if (_tmp1_ > 0) {
 888                 _tmp0_ = TRUE;
 889         } else {
 890                 GeeMapIterator* _tmp2_;
 891                 gboolean _tmp3_ = FALSE;
 892                 _tmp2_ = self->priv->_iter;
 893                 _tmp3_ = gee_map_iterator_has_next (_tmp2_);
 894                 _tmp0_ = _tmp3_;
 895         }
 896         _tmp4_ = _tmp0_;
 897         result = _tmp4_;
 898         return result;
 899 }
 900
 901
 902 static gpointer gee_abstract_multi_set_iterator_real_get (GeeIterator* base) {
 903         GeeAbstractMultiSetIterator * self;
 904         gpointer result = NULL;
 905         gboolean _tmp0_;
 906         GeeMapIterator* _tmp1_;
 907         gpointer _tmp2_ = NULL;
 908         self = (GeeAbstractMultiSetIterator*) base;
 909         _tmp0_ = self->priv->_removed;
 910         _vala_assert (!_tmp0_, "! _removed");
 911         _tmp1_ = self->priv->_iter;
 912         _tmp2_ = gee_map_iterator_get_key (_tmp1_);
 913         result = _tmp2_;
 914         return result;
 915 }
 916
 917
 918 static void gee_abstract_multi_set_iterator_real_remove (GeeIterator* base) {
 919         GeeAbstractMultiSetIterator * self;
 920         gboolean _tmp0_;
 921         GeeMapIterator* _tmp1_;
 922         GeeMapIterator* _tmp2_;
 923         gpointer _tmp3_ = NULL;
 924         gint _tmp4_;
 925         gint _tmp5_;
 926         GeeAbstractMultiSet* _tmp7_;
 927         gint _tmp8_;
 928         self = (GeeAbstractMultiSetIterator*) base;
 929         _tmp0_ = self->priv->_removed;
 930         _vala_assert (!_tmp0_, "! _removed");
 931         _tmp1_ = self->priv->_iter;
 932         _tmp2_ = self->priv->_iter;
 933         _tmp3_ = gee_map_iterator_get_value (_tmp2_);
 934         self->priv->_pending = ((gint) ((gintptr) _tmp3_)) - 1;
 935         _tmp4_ = self->priv->_pending;
 936         gee_map_iterator_set_value (_tmp1_, (gpointer) ((gintptr) _tmp4_));
 937         _tmp5_ = self->priv->_pending;
 938         if (_tmp5_ == 0) {
 939                 GeeMapIterator* _tmp6_;
 940                 _tmp6_ = self->priv->_iter;
 941                 gee_map_iterator_unset (_tmp6_);
 942         }
 943         _tmp7_ = self->priv->_set;
 944         _tmp8_ = _tmp7_->priv->_nitems;
 945         _tmp7_->priv->_nitems = _tmp8_ - 1;
 946         self->priv->_removed = TRUE;
 947 }
 948
 949
 950 static gboolean gee_abstract_multi_set_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
 951         GeeAbstractMultiSetIterator * self;
 952         gboolean result = FALSE;
 953         GeeMapIterator* _tmp0_;
 954         gboolean _tmp1_;
 955         gboolean _tmp2_;
 956         self = (GeeAbstractMultiSetIterator*) base;
 957         _tmp0_ = self->priv->_iter;
 958         _tmp1_ = gee_map_iterator_get_valid (_tmp0_);
 959         _tmp2_ = _tmp1_;
 960         if (_tmp2_) {
 961                 gboolean _tmp3_;
 962                 _tmp3_ = self->priv->_removed;
 963                 if (!_tmp3_) {
 964                         GeeForallFunc _tmp4_;
 965                         void* _tmp4__target;
 966                         GeeMapIterator* _tmp5_;
 967                         gpointer _tmp6_ = NULL;
 968                         gboolean _tmp7_ = FALSE;
 969                         _tmp4_ = f;
 970                         _tmp4__target = f_target;
 971                         _tmp5_ = self->priv->_iter;
 972                         _tmp6_ = gee_map_iterator_get_key (_tmp5_);
 973                         _tmp7_ = _tmp4_ (_tmp6_, _tmp4__target);
 974                         if (!_tmp7_) {
 975                                 result = FALSE;
 976                                 return result;
 977                         }
 978                 }
 979                 {
 980                         gint _tmp8_;
 981                         gint i;
 982                         _tmp8_ = self->priv->_pending;
 983                         i = _tmp8_ - 1;
 984                         {
 985                                 gboolean _tmp9_;
 986                                 _tmp9_ = TRUE;
 987                                 while (TRUE) {
 988                                         gboolean _tmp10_;
 989                                         gint _tmp12_;
 990                                         GeeForallFunc _tmp13_;
 991                                         void* _tmp13__target;
 992                                         GeeMapIterator* _tmp14_;
 993                                         gpointer _tmp15_ = NULL;
 994                                         gboolean _tmp16_ = FALSE;
 995                                         _tmp10_ = _tmp9_;
 996                                         if (!_tmp10_) {
 997                                                 gint _tmp11_;
 998                                                 _tmp11_ = i;
 999                                                 i = _tmp11_ - 1;
1000                                         }
1001                                         _tmp9_ = FALSE;
1002                                         _tmp12_ = i;
1003                                         if (!(_tmp12_ >= 0)) {
1004                                                 break;
1005                                         }
1006                                         _tmp13_ = f;
1007                                         _tmp13__target = f_target;
1008                                         _tmp14_ = self->priv->_iter;
1009                                         _tmp15_ = gee_map_iterator_get_key (_tmp14_);
1010                                         _tmp16_ = _tmp13_ (_tmp15_, _tmp13__target);
1011                                         if (!_tmp16_) {
1012                                                 gint _tmp17_;
1013                                                 _tmp17_ = i;
1014                                                 self->priv->_pending = _tmp17_;
1015                                                 result = FALSE;
1016                                                 return result;
1017                                         }
1018                                 }
1019                         }
1020                 }
1021         }
1022         while (TRUE) {
1023                 GeeMapIterator* _tmp18_;
1024                 gboolean _tmp19_ = FALSE;
1025                 _tmp18_ = self->priv->_iter;
1026                 _tmp19_ = gee_map_iterator_next (_tmp18_);
1027                 if (!_tmp19_) {
1028                         break;
1029                 }
1030                 {
1031                         GeeMapIterator* _tmp20_;
1032                         gpointer _tmp21_ = NULL;
1033                         gint i;
1034                         _tmp20_ = self->priv->_iter;
1035                         _tmp21_ = gee_map_iterator_get_value (_tmp20_);
1036                         i = ((gint) ((gintptr) _tmp21_)) - 1;
1037                         {
1038                                 gboolean _tmp22_;
1039                                 _tmp22_ = TRUE;
1040                                 while (TRUE) {
1041                                         gboolean _tmp23_;
1042                                         gint _tmp25_;
1043                                         GeeForallFunc _tmp26_;
1044                                         void* _tmp26__target;
1045                                         GeeMapIterator* _tmp27_;
1046                                         gpointer _tmp28_ = NULL;
1047                                         gboolean _tmp29_ = FALSE;
1048                                         _tmp23_ = _tmp22_;
1049                                         if (!_tmp23_) {
1050                                                 gint _tmp24_;
1051                                                 _tmp24_ = i;
1052                                                 i = _tmp24_ - 1;
1053                                         }
1054                                         _tmp22_ = FALSE;
1055                                         _tmp25_ = i;
1056                                         if (!(_tmp25_ >= 0)) {
1057                                                 break;
1058                                         }
1059                                         _tmp26_ = f;
1060                                         _tmp26__target = f_target;
1061                                         _tmp27_ = self->priv->_iter;
1062                                         _tmp28_ = gee_map_iterator_get_key (_tmp27_);
1063                                         _tmp29_ = _tmp26_ (_tmp28_, _tmp26__target);
1064                                         if (!_tmp29_) {
1065                                                 gint _tmp30_;
1066                                                 self->priv->_removed = FALSE;
1067                                                 _tmp30_ = i;
1068                                                 self->priv->_pending = _tmp30_;
1069                                                 result = FALSE;
1070                                                 return result;
1071                                         }
1072                                 }
1073                         }
1074                 }
1075         }
1076         self->priv->_removed = FALSE;
1077         self->priv->_pending = 0;
1078         result = TRUE;
1079         return result;
1080 }
1081
1082
1083 static gboolean gee_abstract_multi_set_iterator_real_get_read_only (GeeIterator* base) {
1084         gboolean result;
1085         GeeAbstractMultiSetIterator* self;
1086         self = (GeeAbstractMultiSetIterator*) base;
1087         result = FALSE;
1088         return result;
1089 }
1090
1091
1092 static gboolean gee_abstract_multi_set_iterator_real_get_valid (GeeIterator* base) {
1093         gboolean result;
1094         GeeAbstractMultiSetIterator* self;
1095         gboolean _tmp0_ = FALSE;
1096         gboolean _tmp1_;
1097         gboolean _tmp5_;
1098         self = (GeeAbstractMultiSetIterator*) base;
1099         _tmp1_ = self->priv->_removed;
1100         if (!_tmp1_) {
1101                 GeeMapIterator* _tmp2_;
1102                 gboolean _tmp3_;
1103                 gboolean _tmp4_;
1104                 _tmp2_ = self->priv->_iter;
1105                 _tmp3_ = gee_map_iterator_get_valid (_tmp2_);
1106                 _tmp4_ = _tmp3_;
1107                 _tmp0_ = _tmp4_;
1108         } else {
1109                 _tmp0_ = FALSE;
1110         }
1111         _tmp5_ = _tmp0_;
1112         result = _tmp5_;
1113         return result;
1114 }
1115
1116
1117 static void gee_abstract_multi_set_iterator_class_init (GeeAbstractMultiSetIteratorClass * klass) {
1118         gee_abstract_multi_set_iterator_parent_class = g_type_class_peek_parent (klass);
1119         g_type_class_add_private (klass, sizeof (GeeAbstractMultiSetIteratorPrivate));
1120         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_set_iterator_get_property;
1121         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_set_iterator_set_property;
1122         G_OBJECT_CLASS (klass)->finalize = gee_abstract_multi_set_iterator_finalize;
1123         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_ITERATOR_G_TYPE, g_param_spec_gtype ("g-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));
1124         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_ITERATOR_G_DUP_FUNC, g_param_spec_pointer ("g-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));
1125         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_ITERATOR_G_DESTROY_FUNC, g_param_spec_pointer ("g-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));
1126         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_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));
1127         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_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));
1128 }
1129
1130
1131 static GType gee_abstract_multi_set_iterator_gee_traversable_get_g_type (GeeAbstractMultiSetIterator* self) {
1132         return self->priv->g_type;
1133 }
1134
1135
1136 static GBoxedCopyFunc gee_abstract_multi_set_iterator_gee_traversable_get_g_dup_func (GeeAbstractMultiSetIterator* self) {
1137         return self->priv->g_dup_func;
1138 }
1139
1140
1141 static GDestroyNotify gee_abstract_multi_set_iterator_gee_traversable_get_g_destroy_func (GeeAbstractMultiSetIterator* self) {
1142         return self->priv->g_destroy_func;
1143 }
1144
1145
1146 static void gee_abstract_multi_set_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
1147         gee_abstract_multi_set_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
1148         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_abstract_multi_set_iterator_real_foreach;
1149         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_abstract_multi_set_iterator_gee_traversable_get_g_type;
1150         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_abstract_multi_set_iterator_gee_traversable_get_g_dup_func;
1151         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_abstract_multi_set_iterator_gee_traversable_get_g_destroy_func;
1152 }
1153
1154
1155 static void gee_abstract_multi_set_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
1156         gee_abstract_multi_set_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
1157         iface->next = (gboolean (*)(GeeIterator*)) gee_abstract_multi_set_iterator_real_next;
1158         iface->has_next = (gboolean (*)(GeeIterator*)) gee_abstract_multi_set_iterator_real_has_next;
1159         iface->get = (gpointer (*)(GeeIterator*)) gee_abstract_multi_set_iterator_real_get;
1160         iface->remove = (void (*)(GeeIterator*)) gee_abstract_multi_set_iterator_real_remove;
1161         iface->get_read_only = gee_abstract_multi_set_iterator_real_get_read_only;
1162         iface->get_valid = gee_abstract_multi_set_iterator_real_get_valid;
1163 }
1164
1165
1166 static void gee_abstract_multi_set_iterator_instance_init (GeeAbstractMultiSetIterator * self) {
1167         self->priv = GEE_ABSTRACT_MULTI_SET_ITERATOR_GET_PRIVATE (self);
1168         self->priv->_pending = 0;
1169         self->priv->_removed = FALSE;
1170 }
1171
1172
1173 static void gee_abstract_multi_set_iterator_finalize (GObject* obj) {
1174         GeeAbstractMultiSetIterator * self;
1175         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, GeeAbstractMultiSetIterator);
1176         _g_object_unref0 (self->priv->_set);
1177         _g_object_unref0 (self->priv->_iter);
1178         G_OBJECT_CLASS (gee_abstract_multi_set_iterator_parent_class)->finalize (obj);
1179 }
1180
1181
1182 static GType gee_abstract_multi_set_iterator_get_type (void) {
1183         static volatile gsize gee_abstract_multi_set_iterator_type_id__volatile = 0;
1184         if (g_once_init_enter (&gee_abstract_multi_set_iterator_type_id__volatile)) {
1185                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiSetIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_set_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiSetIterator), 0, (GInstanceInitFunc) gee_abstract_multi_set_iterator_instance_init, NULL };
1186                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_abstract_multi_set_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1187                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_abstract_multi_set_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1188                 GType gee_abstract_multi_set_iterator_type_id;
1189                 gee_abstract_multi_set_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeAbstractMultiSetIterator", &g_define_type_info, 0);
1190                 g_type_add_interface_static (gee_abstract_multi_set_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
1191                 g_type_add_interface_static (gee_abstract_multi_set_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
1192                 g_once_init_leave (&gee_abstract_multi_set_iterator_type_id__volatile, gee_abstract_multi_set_iterator_type_id);
1193         }
1194         return gee_abstract_multi_set_iterator_type_id__volatile;
1195 }
1196
1197
1198 static void _vala_gee_abstract_multi_set_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1199         GeeAbstractMultiSetIterator * self;
1200         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, GeeAbstractMultiSetIterator);
1201         switch (property_id) {
1202                 case GEE_ABSTRACT_MULTI_SET_ITERATOR_READ_ONLY:
1203                 g_value_set_boolean (value, gee_iterator_get_read_only ((GeeIterator*) self));
1204                 break;
1205                 case GEE_ABSTRACT_MULTI_SET_ITERATOR_VALID:
1206                 g_value_set_boolean (value, gee_iterator_get_valid ((GeeIterator*) self));
1207                 break;
1208                 default:
1209                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1210                 break;
1211         }
1212 }
1213
1214
1215 static void _vala_gee_abstract_multi_set_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1216         GeeAbstractMultiSetIterator * self;
1217         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_SET_TYPE_ITERATOR, GeeAbstractMultiSetIterator);
1218         switch (property_id) {
1219                 case GEE_ABSTRACT_MULTI_SET_ITERATOR_G_TYPE:
1220                 self->priv->g_type = g_value_get_gtype (value);
1221                 break;
1222                 case GEE_ABSTRACT_MULTI_SET_ITERATOR_G_DUP_FUNC:
1223                 self->priv->g_dup_func = g_value_get_pointer (value);
1224                 break;
1225                 case GEE_ABSTRACT_MULTI_SET_ITERATOR_G_DESTROY_FUNC:
1226                 self->priv->g_destroy_func = g_value_get_pointer (value);
1227                 break;
1228                 default:
1229                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1230                 break;
1231         }
1232 }
1233
1234
1235 static void gee_abstract_multi_set_class_init (GeeAbstractMultiSetClass * klass) {
1236         gee_abstract_multi_set_parent_class = g_type_class_peek_parent (klass);
1237         g_type_class_add_private (klass, sizeof (GeeAbstractMultiSetPrivate));
1238         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_abstract_multi_set_real_contains;
1239         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_abstract_multi_set_real_iterator;
1240         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_abstract_multi_set_real_add;
1241         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_abstract_multi_set_real_remove;
1242         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_abstract_multi_set_real_clear;
1243         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved0 = gee_abstract_multi_set_real_reserved0;
1244         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved1 = gee_abstract_multi_set_real_reserved1;
1245         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved2 = gee_abstract_multi_set_real_reserved2;
1246         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved3 = gee_abstract_multi_set_real_reserved3;
1247         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved4 = gee_abstract_multi_set_real_reserved4;
1248         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved5 = gee_abstract_multi_set_real_reserved5;
1249         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved6 = gee_abstract_multi_set_real_reserved6;
1250         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved7 = gee_abstract_multi_set_real_reserved7;
1251         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->reserved8 = gee_abstract_multi_set_real_reserved8;
1252         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_abstract_multi_set_real_get_size;
1253         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_abstract_multi_set_real_get_read_only;
1254         GEE_ABSTRACT_MULTI_SET_CLASS (klass)->get_read_only_view = gee_abstract_multi_set_real_get_read_only_view;
1255         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_set_get_property;
1256         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_set_set_property;
1257         G_OBJECT_CLASS (klass)->finalize = gee_abstract_multi_set_finalize;
1258         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_G_TYPE, g_param_spec_gtype ("g-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));
1259         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_G_DUP_FUNC, g_param_spec_pointer ("g-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));
1260         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_G_DESTROY_FUNC, g_param_spec_pointer ("g-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));
1261         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
1262         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_SET_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
1263 }
1264
1265
1266 static GType gee_abstract_multi_set_gee_multi_set_get_g_type (GeeAbstractMultiSet* self) {
1267         return self->priv->g_type;
1268 }
1269
1270
1271 static GBoxedCopyFunc gee_abstract_multi_set_gee_multi_set_get_g_dup_func (GeeAbstractMultiSet* self) {
1272         return self->priv->g_dup_func;
1273 }
1274
1275
1276 static GDestroyNotify gee_abstract_multi_set_gee_multi_set_get_g_destroy_func (GeeAbstractMultiSet* self) {
1277         return self->priv->g_destroy_func;
1278 }
1279
1280
1281 static void gee_abstract_multi_set_gee_multi_set_interface_init (GeeMultiSetIface * iface) {
1282         gee_abstract_multi_set_gee_multi_set_parent_iface = g_type_interface_peek_parent (iface);
1283         iface->count = (gint (*)(GeeMultiSet*, gconstpointer)) gee_abstract_multi_set_real_count;
1284         iface->get_g_type = (GType(*)(GeeMultiSet*)) gee_abstract_multi_set_gee_multi_set_get_g_type;
1285         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeMultiSet*)) gee_abstract_multi_set_gee_multi_set_get_g_dup_func;
1286         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeMultiSet*)) gee_abstract_multi_set_gee_multi_set_get_g_destroy_func;
1287         iface->get_read_only_view = (GeeMultiSet* (*) (GeeMultiSet *)) gee_abstract_multi_set_get_read_only_view;
1288 }
1289
1290
1291 static void gee_abstract_multi_set_instance_init (GeeAbstractMultiSet * self) {
1292         self->priv = GEE_ABSTRACT_MULTI_SET_GET_PRIVATE (self);
1293         self->priv->_nitems = 0;
1294 }
1295
1296
1297 static void gee_abstract_multi_set_finalize (GObject* obj) {
1298         GeeAbstractMultiSet * self;
1299         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_ABSTRACT_MULTI_SET, GeeAbstractMultiSet);
1300         _g_object_unref0 (self->_storage_map);
1301         G_OBJECT_CLASS (gee_abstract_multi_set_parent_class)->finalize (obj);
1302 }
1303
1304
1305 /**
1306  * Skeletal implementation of the {@link MultiSet} interface.
1307  *
1308  * @see HashMultiSet
1309  * @see TreeMultiSet
1310  */
1311 GType gee_abstract_multi_set_get_type (void) {
1312         static volatile gsize gee_abstract_multi_set_type_id__volatile = 0;
1313         if (g_once_init_enter (&gee_abstract_multi_set_type_id__volatile)) {
1314                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiSetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiSet), 0, (GInstanceInitFunc) gee_abstract_multi_set_instance_init, NULL };
1315                 static const GInterfaceInfo gee_multi_set_info = { (GInterfaceInitFunc) gee_abstract_multi_set_gee_multi_set_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1316                 GType gee_abstract_multi_set_type_id;
1317                 gee_abstract_multi_set_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_COLLECTION, "GeeAbstractMultiSet", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
1318                 g_type_add_interface_static (gee_abstract_multi_set_type_id, GEE_TYPE_MULTI_SET, &gee_multi_set_info);
1319                 g_once_init_leave (&gee_abstract_multi_set_type_id__volatile, gee_abstract_multi_set_type_id);
1320         }
1321         return gee_abstract_multi_set_type_id__volatile;
1322 }
1323
1324
1325 static void _vala_gee_abstract_multi_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1326         GeeAbstractMultiSet * self;
1327         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_ABSTRACT_MULTI_SET, GeeAbstractMultiSet);
1328         switch (property_id) {
1329                 case GEE_ABSTRACT_MULTI_SET_SIZE:
1330                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
1331                 break;
1332                 case GEE_ABSTRACT_MULTI_SET_READ_ONLY:
1333                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
1334                 break;
1335                 default:
1336                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1337                 break;
1338         }
1339 }
1340
1341
1342 static void _vala_gee_abstract_multi_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1343         GeeAbstractMultiSet * self;
1344         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_ABSTRACT_MULTI_SET, GeeAbstractMultiSet);
1345         switch (property_id) {
1346                 case GEE_ABSTRACT_MULTI_SET_G_TYPE:
1347                 self->priv->g_type = g_value_get_gtype (value);
1348                 break;
1349                 case GEE_ABSTRACT_MULTI_SET_G_DUP_FUNC:
1350                 self->priv->g_dup_func = g_value_get_pointer (value);
1351                 break;
1352                 case GEE_ABSTRACT_MULTI_SET_G_DESTROY_FUNC:
1353                 self->priv->g_destroy_func = g_value_get_pointer (value);
1354                 break;
1355                 default:
1356                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1357                 break;
1358         }
1359 }
1360
1361
1362