gee/abstractmultimap.c

   1 /* abstractmultimap.c generated by valac 0.18.0, the Vala compiler
   2  * generated from abstractmultimap.vala, do not modify */
   3
   4 /* abstractmultimap.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_MULTI_MAP (gee_multi_map_get_type ())
  32 #define GEE_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MULTI_MAP, GeeMultiMap))
  33 #define GEE_IS_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MULTI_MAP))
  34 #define GEE_MULTI_MAP_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MULTI_MAP, GeeMultiMapIface))
  35
  36 typedef struct _GeeMultiMap GeeMultiMap;
  37 typedef struct _GeeMultiMapIface GeeMultiMapIface;
  38
  39 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  40 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  41 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  42 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  43
  44 typedef struct _GeeTraversable GeeTraversable;
  45 typedef struct _GeeTraversableIface GeeTraversableIface;
  46
  47 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  48
  49 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  50 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  51 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  52 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  53 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  54 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  55
  56 typedef struct _GeeLazy GeeLazy;
  57 typedef struct _GeeLazyClass GeeLazyClass;
  58
  59 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  60 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  61 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  62 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  63
  64 typedef struct _GeeIterator GeeIterator;
  65 typedef struct _GeeIteratorIface GeeIteratorIface;
  66
  67 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  68 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  69 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  70 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  71
  72 typedef struct _GeeIterable GeeIterable;
  73 typedef struct _GeeIterableIface GeeIterableIface;
  74
  75 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  76 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  77 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  78 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  79
  80 typedef struct _GeeCollection GeeCollection;
  81 typedef struct _GeeCollectionIface GeeCollectionIface;
  82
  83 #define GEE_TYPE_SET (gee_set_get_type ())
  84 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
  85 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
  86 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
  87
  88 typedef struct _GeeSet GeeSet;
  89 typedef struct _GeeSetIface GeeSetIface;
  90
  91 #define GEE_TYPE_MULTI_SET (gee_multi_set_get_type ())
  92 #define GEE_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MULTI_SET, GeeMultiSet))
  93 #define GEE_IS_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MULTI_SET))
  94 #define GEE_MULTI_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MULTI_SET, GeeMultiSetIface))
  95
  96 typedef struct _GeeMultiSet GeeMultiSet;
  97 typedef struct _GeeMultiSetIface GeeMultiSetIface;
  98
  99 #define GEE_TYPE_MAP_ITERATOR (gee_map_iterator_get_type ())
 100 #define GEE_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIterator))
 101 #define GEE_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP_ITERATOR))
 102 #define GEE_MAP_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIteratorIface))
 103
 104 typedef struct _GeeMapIterator GeeMapIterator;
 105 typedef struct _GeeMapIteratorIface GeeMapIteratorIface;
 106
 107 #define GEE_TYPE_ABSTRACT_MULTI_MAP (gee_abstract_multi_map_get_type ())
 108 #define GEE_ABSTRACT_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_MULTI_MAP, GeeAbstractMultiMap))
 109 #define GEE_ABSTRACT_MULTI_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_MULTI_MAP, GeeAbstractMultiMapClass))
 110 #define GEE_IS_ABSTRACT_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_MULTI_MAP))
 111 #define GEE_IS_ABSTRACT_MULTI_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_MULTI_MAP))
 112 #define GEE_ABSTRACT_MULTI_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_MULTI_MAP, GeeAbstractMultiMapClass))
 113
 114 typedef struct _GeeAbstractMultiMap GeeAbstractMultiMap;
 115 typedef struct _GeeAbstractMultiMapClass GeeAbstractMultiMapClass;
 116 typedef struct _GeeAbstractMultiMapPrivate GeeAbstractMultiMapPrivate;
 117
 118 #define GEE_TYPE_MAP (gee_map_get_type ())
 119 #define GEE_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP, GeeMap))
 120 #define GEE_IS_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP))
 121 #define GEE_MAP_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP, GeeMapIface))
 122
 123 typedef struct _GeeMap GeeMap;
 124 typedef struct _GeeMapIface GeeMapIface;
 125
 126 #define GEE_MAP_TYPE_ENTRY (gee_map_entry_get_type ())
 127 #define GEE_MAP_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntry))
 128 #define GEE_MAP_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 129 #define GEE_MAP_IS_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_MAP_TYPE_ENTRY))
 130 #define GEE_MAP_IS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_MAP_TYPE_ENTRY))
 131 #define GEE_MAP_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_MAP_TYPE_ENTRY, GeeMapEntryClass))
 132
 133 typedef struct _GeeMapEntry GeeMapEntry;
 134 typedef struct _GeeMapEntryClass GeeMapEntryClass;
 135 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 136
 137 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
 138 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
 139 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
 140 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
 141 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
 142 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
 143
 144 typedef struct _GeeAbstractCollection GeeAbstractCollection;
 145 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
 146
 147 #define GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS (gee_abstract_multi_map_all_keys_get_type ())
 148 #define GEE_ABSTRACT_MULTI_MAP_ALL_KEYS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, GeeAbstractMultiMapAllKeys))
 149 #define GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, GeeAbstractMultiMapAllKeysClass))
 150 #define GEE_ABSTRACT_MULTI_MAP_IS_ALL_KEYS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS))
 151 #define GEE_ABSTRACT_MULTI_MAP_IS_ALL_KEYS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS))
 152 #define GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, GeeAbstractMultiMapAllKeysClass))
 153
 154 typedef struct _GeeAbstractMultiMapAllKeys GeeAbstractMultiMapAllKeys;
 155 typedef struct _GeeAbstractMultiMapAllKeysClass GeeAbstractMultiMapAllKeysClass;
 156
 157 #define GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES (gee_abstract_multi_map_values_get_type ())
 158 #define GEE_ABSTRACT_MULTI_MAP_VALUES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, GeeAbstractMultiMapValues))
 159 #define GEE_ABSTRACT_MULTI_MAP_VALUES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, GeeAbstractMultiMapValuesClass))
 160 #define GEE_ABSTRACT_MULTI_MAP_IS_VALUES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES))
 161 #define GEE_ABSTRACT_MULTI_MAP_IS_VALUES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES))
 162 #define GEE_ABSTRACT_MULTI_MAP_VALUES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, GeeAbstractMultiMapValuesClass))
 163
 164 typedef struct _GeeAbstractMultiMapValues GeeAbstractMultiMapValues;
 165 typedef struct _GeeAbstractMultiMapValuesClass GeeAbstractMultiMapValuesClass;
 166
 167 #define GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR (gee_abstract_multi_map_mapping_iterator_get_type ())
 168 #define GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, GeeAbstractMultiMapMappingIterator))
 169 #define GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, GeeAbstractMultiMapMappingIteratorClass))
 170 #define GEE_ABSTRACT_MULTI_MAP_IS_MAPPING_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR))
 171 #define GEE_ABSTRACT_MULTI_MAP_IS_MAPPING_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR))
 172 #define GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, GeeAbstractMultiMapMappingIteratorClass))
 173
 174 typedef struct _GeeAbstractMultiMapMappingIterator GeeAbstractMultiMapMappingIterator;
 175 typedef struct _GeeAbstractMultiMapMappingIteratorClass GeeAbstractMultiMapMappingIteratorClass;
 176
 177 #define GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR (gee_abstract_multi_map_map_iterator_get_type ())
 178 #define GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR, GeeAbstractMultiMapMapIterator))
 179 #define GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR, GeeAbstractMultiMapMapIteratorClass))
 180 #define GEE_ABSTRACT_MULTI_MAP_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR))
 181 #define GEE_ABSTRACT_MULTI_MAP_IS_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR))
 182 #define GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR, GeeAbstractMultiMapMapIteratorClass))
 183
 184 typedef struct _GeeAbstractMultiMapMapIterator GeeAbstractMultiMapMapIterator;
 185 typedef struct _GeeAbstractMultiMapMapIteratorClass GeeAbstractMultiMapMapIteratorClass;
 186
 187 #define GEE_TYPE_READ_ONLY_MULTI_MAP (gee_read_only_multi_map_get_type ())
 188 #define GEE_READ_ONLY_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_MULTI_MAP, GeeReadOnlyMultiMap))
 189 #define GEE_READ_ONLY_MULTI_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_MULTI_MAP, GeeReadOnlyMultiMapClass))
 190 #define GEE_IS_READ_ONLY_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_MULTI_MAP))
 191 #define GEE_IS_READ_ONLY_MULTI_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_MULTI_MAP))
 192 #define GEE_READ_ONLY_MULTI_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_MULTI_MAP, GeeReadOnlyMultiMapClass))
 193
 194 typedef struct _GeeReadOnlyMultiMap GeeReadOnlyMultiMap;
 195 typedef struct _GeeReadOnlyMultiMapClass GeeReadOnlyMultiMapClass;
 196 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
 197 typedef struct _GeeAbstractMultiMapAllKeysPrivate GeeAbstractMultiMapAllKeysPrivate;
 198
 199 #define GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR (gee_abstract_multi_map_key_iterator_get_type ())
 200 #define GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR, GeeAbstractMultiMapKeyIterator))
 201 #define GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR, GeeAbstractMultiMapKeyIteratorClass))
 202 #define GEE_ABSTRACT_MULTI_MAP_IS_KEY_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR))
 203 #define GEE_ABSTRACT_MULTI_MAP_IS_KEY_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR))
 204 #define GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR, GeeAbstractMultiMapKeyIteratorClass))
 205
 206 typedef struct _GeeAbstractMultiMapKeyIterator GeeAbstractMultiMapKeyIterator;
 207 typedef struct _GeeAbstractMultiMapKeyIteratorClass GeeAbstractMultiMapKeyIteratorClass;
 208 typedef struct _GeeAbstractMultiMapValuesPrivate GeeAbstractMultiMapValuesPrivate;
 209
 210 #define GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR (gee_abstract_multi_map_value_iterator_get_type ())
 211 #define GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR, GeeAbstractMultiMapValueIterator))
 212 #define GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR, GeeAbstractMultiMapValueIteratorClass))
 213 #define GEE_ABSTRACT_MULTI_MAP_IS_VALUE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR))
 214 #define GEE_ABSTRACT_MULTI_MAP_IS_VALUE_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR))
 215 #define GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR, GeeAbstractMultiMapValueIteratorClass))
 216
 217 typedef struct _GeeAbstractMultiMapValueIterator GeeAbstractMultiMapValueIterator;
 218 typedef struct _GeeAbstractMultiMapValueIteratorClass GeeAbstractMultiMapValueIteratorClass;
 219 typedef struct _GeeAbstractMultiMapMappingIteratorPrivate GeeAbstractMultiMapMappingIteratorPrivate;
 220 typedef struct _GeeAbstractMultiMapKeyIteratorPrivate GeeAbstractMultiMapKeyIteratorPrivate;
 221 typedef struct _Block1Data Block1Data;
 222 typedef struct _Block2Data Block2Data;
 223 typedef struct _Block3Data Block3Data;
 224 typedef struct _GeeAbstractMultiMapValueIteratorPrivate GeeAbstractMultiMapValueIteratorPrivate;
 225 typedef struct _Block4Data Block4Data;
 226 typedef struct _GeeAbstractMultiMapMapIteratorPrivate GeeAbstractMultiMapMapIteratorPrivate;
 227 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 228
 229 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 230 typedef enum  {
 231         GEE_TRAVERSABLE_STREAM_YIELD,
 232         GEE_TRAVERSABLE_STREAM_CONTINUE,
 233         GEE_TRAVERSABLE_STREAM_END
 234 } GeeTraversableStream;
 235
 236 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 237 struct _GeeIteratorIface {
 238         GTypeInterface parent_iface;
 239         gboolean (*next) (GeeIterator* self);
 240         gboolean (*has_next) (GeeIterator* self);
 241         gpointer (*get) (GeeIterator* self);
 242         void (*remove) (GeeIterator* self);
 243         gboolean (*get_valid) (GeeIterator* self);
 244         gboolean (*get_read_only) (GeeIterator* self);
 245 };
 246
 247 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 248 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 249 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 250 struct _GeeTraversableIface {
 251         GTypeInterface parent_iface;
 252         GType (*get_g_type) (GeeTraversable* self);
 253         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 254         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 255         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 256         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);
 257         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 258         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 259         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 260         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 261         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 262         GType (*get_element_type) (GeeTraversable* self);
 263 };
 264
 265 struct _GeeIterableIface {
 266         GTypeInterface parent_iface;
 267         GType (*get_g_type) (GeeIterable* self);
 268         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 269         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 270         GeeIterator* (*iterator) (GeeIterable* self);
 271 };
 272
 273 struct _GeeCollectionIface {
 274         GTypeInterface parent_iface;
 275         GType (*get_g_type) (GeeCollection* self);
 276         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 277         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 278         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 279         gboolean (*add) (GeeCollection* self, gconstpointer item);
 280         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 281         void (*clear) (GeeCollection* self);
 282         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 283         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 284         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 285         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 286         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 287         gint (*get_size) (GeeCollection* self);
 288         gboolean (*get_is_empty) (GeeCollection* self);
 289         gboolean (*get_read_only) (GeeCollection* self);
 290         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 291 };
 292
 293 struct _GeeSetIface {
 294         GTypeInterface parent_iface;
 295         GType (*get_g_type) (GeeSet* self);
 296         GBoxedCopyFunc (*get_g_dup_func) (GeeSet* self);
 297         GDestroyNotify (*get_g_destroy_func) (GeeSet* self);
 298         GeeSet* (*get_read_only_view) (GeeSet* self);
 299 };
 300
 301 struct _GeeMultiSetIface {
 302         GTypeInterface parent_iface;
 303         GType (*get_g_type) (GeeMultiSet* self);
 304         GBoxedCopyFunc (*get_g_dup_func) (GeeMultiSet* self);
 305         GDestroyNotify (*get_g_destroy_func) (GeeMultiSet* self);
 306         gint (*count) (GeeMultiSet* self, gconstpointer item);
 307         GeeMultiSet* (*get_read_only_view) (GeeMultiSet* self);
 308 };
 309
 310 typedef gpointer (*GeeFoldMapFunc) (gconstpointer k, gconstpointer v, gpointer a, void* user_data);
 311 typedef gboolean (*GeeForallMapFunc) (gconstpointer k, gconstpointer v, void* user_data);
 312 struct _GeeMapIteratorIface {
 313         GTypeInterface parent_iface;
 314         GType (*get_k_type) (GeeMapIterator* self);
 315         GBoxedCopyFunc (*get_k_dup_func) (GeeMapIterator* self);
 316         GDestroyNotify (*get_k_destroy_func) (GeeMapIterator* self);
 317         GType (*get_v_type) (GeeMapIterator* self);
 318         GBoxedCopyFunc (*get_v_dup_func) (GeeMapIterator* self);
 319         GDestroyNotify (*get_v_destroy_func) (GeeMapIterator* self);
 320         gboolean (*next) (GeeMapIterator* self);
 321         gboolean (*has_next) (GeeMapIterator* self);
 322         gpointer (*get_key) (GeeMapIterator* self);
 323         gpointer (*get_value) (GeeMapIterator* self);
 324         void (*set_value) (GeeMapIterator* self, gconstpointer value);
 325         void (*unset) (GeeMapIterator* self);
 326         gpointer (*fold) (GeeMapIterator* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldMapFunc f, void* f_target, gpointer seed);
 327         gboolean (*foreach) (GeeMapIterator* self, GeeForallMapFunc f, void* f_target);
 328         gboolean (*get_valid) (GeeMapIterator* self);
 329         gboolean (*get_mutable) (GeeMapIterator* self);
 330         gboolean (*get_read_only) (GeeMapIterator* self);
 331 };
 332
 333 struct _GeeMultiMapIface {
 334         GTypeInterface parent_iface;
 335         GType (*get_k_type) (GeeMultiMap* self);
 336         GBoxedCopyFunc (*get_k_dup_func) (GeeMultiMap* self);
 337         GDestroyNotify (*get_k_destroy_func) (GeeMultiMap* self);
 338         GType (*get_v_type) (GeeMultiMap* self);
 339         GBoxedCopyFunc (*get_v_dup_func) (GeeMultiMap* self);
 340         GDestroyNotify (*get_v_destroy_func) (GeeMultiMap* self);
 341         GeeSet* (*get_keys) (GeeMultiMap* self);
 342         GeeMultiSet* (*get_all_keys) (GeeMultiMap* self);
 343         GeeCollection* (*get_values) (GeeMultiMap* self);
 344         gboolean (*contains) (GeeMultiMap* self, gconstpointer key);
 345         GeeCollection* (*get) (GeeMultiMap* self, gconstpointer key);
 346         void (*set) (GeeMultiMap* self, gconstpointer key, gconstpointer value);
 347         gboolean (*remove) (GeeMultiMap* self, gconstpointer key, gconstpointer value);
 348         gboolean (*remove_all) (GeeMultiMap* self, gconstpointer key);
 349         void (*clear) (GeeMultiMap* self);
 350         GeeMapIterator* (*map_iterator) (GeeMultiMap* self);
 351         gint (*get_size) (GeeMultiMap* self);
 352         gboolean (*get_read_only) (GeeMultiMap* self);
 353         GeeMultiMap* (*get_read_only_view) (GeeMultiMap* self);
 354 };
 355
 356 typedef gboolean (*GeeEqualDataFunc) (gconstpointer a, gconstpointer b, void* user_data);
 357 struct _GeeMapIface {
 358         GTypeInterface parent_iface;
 359         GType (*get_k_type) (GeeMap* self);
 360         GBoxedCopyFunc (*get_k_dup_func) (GeeMap* self);
 361         GDestroyNotify (*get_k_destroy_func) (GeeMap* self);
 362         GType (*get_v_type) (GeeMap* self);
 363         GBoxedCopyFunc (*get_v_dup_func) (GeeMap* self);
 364         GDestroyNotify (*get_v_destroy_func) (GeeMap* self);
 365         gboolean (*has_key) (GeeMap* self, gconstpointer key);
 366         gboolean (*has) (GeeMap* self, gconstpointer key, gconstpointer value);
 367         gpointer (*get) (GeeMap* self, gconstpointer key);
 368         void (*set) (GeeMap* self, gconstpointer key, gconstpointer value);
 369         gboolean (*unset) (GeeMap* self, gconstpointer key, gpointer* value);
 370         void (*clear) (GeeMap* self);
 371         GeeMapIterator* (*map_iterator) (GeeMap* self);
 372         void (*set_all) (GeeMap* self, GeeMap* map);
 373         gboolean (*unset_all) (GeeMap* self, GeeMap* map);
 374         gboolean (*has_all) (GeeMap* self, GeeMap* map);
 375         gint (*get_size) (GeeMap* self);
 376         gboolean (*get_is_empty) (GeeMap* self);
 377         gboolean (*get_read_only) (GeeMap* self);
 378         GeeSet* (*get_keys) (GeeMap* self);
 379         GeeCollection* (*get_values) (GeeMap* self);
 380         GeeSet* (*get_entries) (GeeMap* self);
 381         GeeMap* (*get_read_only_view) (GeeMap* self);
 382 };
 383
 384 struct _GeeAbstractMultiMap {
 385         GObject parent_instance;
 386         GeeAbstractMultiMapPrivate * priv;
 387         GeeMap* _storage_map;
 388 };
 389
 390 struct _GeeAbstractMultiMapClass {
 391         GObjectClass parent_class;
 392         GeeCollection* (*create_value_storage) (GeeAbstractMultiMap* self);
 393         GeeMultiSet* (*create_multi_key_set) (GeeAbstractMultiMap* self);
 394         GeeEqualDataFunc (*get_value_equal_func) (GeeAbstractMultiMap* self, void** result_target, GDestroyNotify* result_target_destroy_notify);
 395         void (*reserved0) (GeeAbstractMultiMap* self);
 396         void (*reserved1) (GeeAbstractMultiMap* self);
 397         void (*reserved2) (GeeAbstractMultiMap* self);
 398         void (*reserved3) (GeeAbstractMultiMap* self);
 399         void (*reserved4) (GeeAbstractMultiMap* self);
 400         void (*reserved5) (GeeAbstractMultiMap* self);
 401         void (*reserved6) (GeeAbstractMultiMap* self);
 402         void (*reserved7) (GeeAbstractMultiMap* self);
 403         void (*reserved8) (GeeAbstractMultiMap* self);
 404         GeeMultiMap* (*get_read_only_view) (GeeAbstractMultiMap* self);
 405 };
 406
 407 struct _GeeAbstractMultiMapPrivate {
 408         GType k_type;
 409         GBoxedCopyFunc k_dup_func;
 410         GDestroyNotify k_destroy_func;
 411         GType v_type;
 412         GBoxedCopyFunc v_dup_func;
 413         GDestroyNotify v_destroy_func;
 414         gint _nitems;
 415         GeeMultiMap* _read_only_view;
 416 };
 417
 418 struct _GeeAbstractCollection {
 419         GObject parent_instance;
 420         GeeAbstractCollectionPrivate * priv;
 421 };
 422
 423 struct _GeeAbstractCollectionClass {
 424         GObjectClass parent_class;
 425         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 426         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 427         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 428         void (*clear) (GeeAbstractCollection* self);
 429         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 430         gboolean (*foreach) (GeeAbstractCollection* self, GeeForallFunc f, void* f_target);
 431         void (*reserved0) (GeeAbstractCollection* self);
 432         void (*reserved1) (GeeAbstractCollection* self);
 433         void (*reserved2) (GeeAbstractCollection* self);
 434         void (*reserved3) (GeeAbstractCollection* self);
 435         void (*reserved4) (GeeAbstractCollection* self);
 436         void (*reserved5) (GeeAbstractCollection* self);
 437         void (*reserved6) (GeeAbstractCollection* self);
 438         void (*reserved7) (GeeAbstractCollection* self);
 439         void (*reserved8) (GeeAbstractCollection* self);
 440         void (*reserved9) (GeeAbstractCollection* self);
 441         gint (*get_size) (GeeAbstractCollection* self);
 442         gboolean (*get_read_only) (GeeAbstractCollection* self);
 443         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 444 };
 445
 446 struct _GeeAbstractMultiMapAllKeys {
 447         GeeAbstractCollection parent_instance;
 448         GeeAbstractMultiMapAllKeysPrivate * priv;
 449         GeeAbstractMultiMap* _multi_map;
 450 };
 451
 452 struct _GeeAbstractMultiMapAllKeysClass {
 453         GeeAbstractCollectionClass parent_class;
 454 };
 455
 456 struct _GeeAbstractMultiMapAllKeysPrivate {
 457         GType k_type;
 458         GBoxedCopyFunc k_dup_func;
 459         GDestroyNotify k_destroy_func;
 460         GType v_type;
 461         GBoxedCopyFunc v_dup_func;
 462         GDestroyNotify v_destroy_func;
 463 };
 464
 465 struct _GeeAbstractMultiMapValues {
 466         GeeAbstractCollection parent_instance;
 467         GeeAbstractMultiMapValuesPrivate * priv;
 468         GeeAbstractMultiMap* _multi_map;
 469 };
 470
 471 struct _GeeAbstractMultiMapValuesClass {
 472         GeeAbstractCollectionClass parent_class;
 473 };
 474
 475 struct _GeeAbstractMultiMapValuesPrivate {
 476         GType k_type;
 477         GBoxedCopyFunc k_dup_func;
 478         GDestroyNotify k_destroy_func;
 479         GType v_type;
 480         GBoxedCopyFunc v_dup_func;
 481         GDestroyNotify v_destroy_func;
 482 };
 483
 484 struct _GeeAbstractMultiMapMappingIterator {
 485         GObject parent_instance;
 486         GeeAbstractMultiMapMappingIteratorPrivate * priv;
 487         GeeMapIterator* outer;
 488         GeeIterator* inner;
 489 };
 490
 491 struct _GeeAbstractMultiMapMappingIteratorClass {
 492         GObjectClass parent_class;
 493         gboolean (*get_read_only) (GeeAbstractMultiMapMappingIterator* self);
 494 };
 495
 496 struct _GeeAbstractMultiMapMappingIteratorPrivate {
 497         GType k_type;
 498         GBoxedCopyFunc k_dup_func;
 499         GDestroyNotify k_destroy_func;
 500         GType v_type;
 501         GBoxedCopyFunc v_dup_func;
 502         GDestroyNotify v_destroy_func;
 503 };
 504
 505 struct _GeeAbstractMultiMapKeyIterator {
 506         GeeAbstractMultiMapMappingIterator parent_instance;
 507         GeeAbstractMultiMapKeyIteratorPrivate * priv;
 508 };
 509
 510 struct _GeeAbstractMultiMapKeyIteratorClass {
 511         GeeAbstractMultiMapMappingIteratorClass parent_class;
 512 };
 513
 514 struct _GeeAbstractMultiMapKeyIteratorPrivate {
 515         GType k_type;
 516         GBoxedCopyFunc k_dup_func;
 517         GDestroyNotify k_destroy_func;
 518         GType v_type;
 519         GBoxedCopyFunc v_dup_func;
 520         GDestroyNotify v_destroy_func;
 521 };
 522
 523 struct _Block1Data {
 524         int _ref_count_;
 525         GeeAbstractMultiMapKeyIterator * self;
 526         GeeForallFunc f;
 527         gpointer f_target;
 528 };
 529
 530 struct _Block2Data {
 531         int _ref_count_;
 532         Block1Data * _data1_;
 533         gpointer key;
 534 };
 535
 536 struct _Block3Data {
 537         int _ref_count_;
 538         Block1Data * _data1_;
 539         gpointer key;
 540 };
 541
 542 struct _GeeAbstractMultiMapValueIterator {
 543         GeeAbstractMultiMapMappingIterator parent_instance;
 544         GeeAbstractMultiMapValueIteratorPrivate * priv;
 545 };
 546
 547 struct _GeeAbstractMultiMapValueIteratorClass {
 548         GeeAbstractMultiMapMappingIteratorClass parent_class;
 549 };
 550
 551 struct _GeeAbstractMultiMapValueIteratorPrivate {
 552         GType k_type;
 553         GBoxedCopyFunc k_dup_func;
 554         GDestroyNotify k_destroy_func;
 555         GType v_type;
 556         GBoxedCopyFunc v_dup_func;
 557         GDestroyNotify v_destroy_func;
 558 };
 559
 560 struct _Block4Data {
 561         int _ref_count_;
 562         GeeAbstractMultiMapValueIterator * self;
 563         GeeForallFunc f;
 564         gpointer f_target;
 565 };
 566
 567 struct _GeeAbstractMultiMapMapIterator {
 568         GeeAbstractMultiMapMappingIterator parent_instance;
 569         GeeAbstractMultiMapMapIteratorPrivate * priv;
 570 };
 571
 572 struct _GeeAbstractMultiMapMapIteratorClass {
 573         GeeAbstractMultiMapMappingIteratorClass parent_class;
 574 };
 575
 576 struct _GeeAbstractMultiMapMapIteratorPrivate {
 577         GType k_type;
 578         GBoxedCopyFunc k_dup_func;
 579         GDestroyNotify k_destroy_func;
 580         GType v_type;
 581         GBoxedCopyFunc v_dup_func;
 582         GDestroyNotify v_destroy_func;
 583 };
 584
 585
 586 static gpointer gee_abstract_multi_map_parent_class = NULL;
 587 static gpointer gee_abstract_multi_map_all_keys_parent_class = NULL;
 588 static GeeMultiSetIface* gee_abstract_multi_map_all_keys_gee_multi_set_parent_iface = NULL;
 589 static gpointer gee_abstract_multi_map_values_parent_class = NULL;
 590 static gpointer gee_abstract_multi_map_mapping_iterator_parent_class = NULL;
 591 static gpointer gee_abstract_multi_map_key_iterator_parent_class = NULL;
 592 static GeeTraversableIface* gee_abstract_multi_map_key_iterator_gee_traversable_parent_iface = NULL;
 593 static GeeIteratorIface* gee_abstract_multi_map_key_iterator_gee_iterator_parent_iface = NULL;
 594 static gpointer gee_abstract_multi_map_value_iterator_parent_class = NULL;
 595 static GeeTraversableIface* gee_abstract_multi_map_value_iterator_gee_traversable_parent_iface = NULL;
 596 static GeeIteratorIface* gee_abstract_multi_map_value_iterator_gee_iterator_parent_iface = NULL;
 597 static gpointer gee_abstract_multi_map_map_iterator_parent_class = NULL;
 598 static GeeMapIteratorIface* gee_abstract_multi_map_map_iterator_gee_map_iterator_parent_iface = NULL;
 599 static GeeMultiMapIface* gee_abstract_multi_map_gee_multi_map_parent_iface = NULL;
 600
 601 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 602 gpointer gee_lazy_ref (gpointer instance);
 603 void gee_lazy_unref (gpointer instance);
 604 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 605 void gee_value_set_lazy (GValue* value, gpointer v_object);
 606 void gee_value_take_lazy (GValue* value, gpointer v_object);
 607 gpointer gee_value_get_lazy (const GValue* value);
 608 GType gee_lazy_get_type (void) G_GNUC_CONST;
 609 GType gee_iterator_get_type (void) G_GNUC_CONST;
 610 GType gee_traversable_get_type (void) G_GNUC_CONST;
 611 GType gee_iterable_get_type (void) G_GNUC_CONST;
 612 GType gee_collection_get_type (void) G_GNUC_CONST;
 613 GType gee_set_get_type (void) G_GNUC_CONST;
 614 GType gee_multi_set_get_type (void) G_GNUC_CONST;
 615 GType gee_map_iterator_get_type (void) G_GNUC_CONST;
 616 GType gee_multi_map_get_type (void) G_GNUC_CONST;
 617 GType gee_abstract_multi_map_get_type (void) G_GNUC_CONST;
 618 GType gee_map_entry_get_type (void) G_GNUC_CONST;
 619 GType gee_map_get_type (void) G_GNUC_CONST;
 620 #define GEE_ABSTRACT_MULTI_MAP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_ABSTRACT_MULTI_MAP, GeeAbstractMultiMapPrivate))
 621 enum  {
 622         GEE_ABSTRACT_MULTI_MAP_DUMMY_PROPERTY,
 623         GEE_ABSTRACT_MULTI_MAP_K_TYPE,
 624         GEE_ABSTRACT_MULTI_MAP_K_DUP_FUNC,
 625         GEE_ABSTRACT_MULTI_MAP_K_DESTROY_FUNC,
 626         GEE_ABSTRACT_MULTI_MAP_V_TYPE,
 627         GEE_ABSTRACT_MULTI_MAP_V_DUP_FUNC,
 628         GEE_ABSTRACT_MULTI_MAP_V_DESTROY_FUNC,
 629         GEE_ABSTRACT_MULTI_MAP_SIZE,
 630         GEE_ABSTRACT_MULTI_MAP_READ_ONLY
 631 };
 632 GeeAbstractMultiMap* gee_abstract_multi_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMap* storage_map);
 633 static GeeSet* gee_abstract_multi_map_real_get_keys (GeeMultiMap* base);
 634 GeeSet* gee_map_get_keys (GeeMap* self);
 635 static GeeMultiSet* gee_abstract_multi_map_real_get_all_keys (GeeMultiMap* base);
 636 static GeeAbstractMultiMapAllKeys* gee_abstract_multi_map_all_keys_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeAbstractMultiMap* multi_map);
 637 static GeeAbstractMultiMapAllKeys* gee_abstract_multi_map_all_keys_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, GeeAbstractMultiMap* multi_map);
 638 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 639 static GType gee_abstract_multi_map_all_keys_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 640 static GeeCollection* gee_abstract_multi_map_real_get_values (GeeMultiMap* base);
 641 static GeeAbstractMultiMapValues* gee_abstract_multi_map_values_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeAbstractMultiMap* multi_map);
 642 static GeeAbstractMultiMapValues* gee_abstract_multi_map_values_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, GeeAbstractMultiMap* multi_map);
 643 static GType gee_abstract_multi_map_values_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 644 static gboolean gee_abstract_multi_map_real_contains (GeeMultiMap* base, gconstpointer key);
 645 gboolean gee_map_has_key (GeeMap* self, gconstpointer key);
 646 static GeeCollection* gee_abstract_multi_map_real_get (GeeMultiMap* base, gconstpointer key);
 647 gpointer gee_map_get (GeeMap* self, gconstpointer key);
 648 GeeCollection* gee_collection_get_read_only_view (GeeCollection* self);
 649 GeeSet* gee_set_empty (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 650 static void gee_abstract_multi_map_real_set (GeeMultiMap* base, gconstpointer key, gconstpointer value);
 651 gboolean gee_collection_add (GeeCollection* self, gconstpointer item);
 652 GeeCollection* gee_abstract_multi_map_create_value_storage (GeeAbstractMultiMap* self);
 653 void gee_map_set (GeeMap* self, gconstpointer key, gconstpointer value);
 654 static gboolean gee_abstract_multi_map_real_remove (GeeMultiMap* base, gconstpointer key, gconstpointer value);
 655 gboolean gee_collection_contains (GeeCollection* self, gconstpointer item);
 656 gboolean gee_collection_remove (GeeCollection* self, gconstpointer item);
 657 gint gee_collection_get_size (GeeCollection* self);
 658 gboolean gee_map_unset (GeeMap* self, gconstpointer key, gpointer* value);
 659 static gboolean gee_abstract_multi_map_real_remove_all (GeeMultiMap* base, gconstpointer key);
 660 static void gee_abstract_multi_map_real_clear (GeeMultiMap* base);
 661 void gee_map_clear (GeeMap* self);
 662 static GeeMapIterator* gee_abstract_multi_map_real_map_iterator (GeeMultiMap* base);
 663 GeeMapIterator* gee_map_map_iterator (GeeMap* self);
 664 static GeeAbstractMultiMapMapIterator* gee_abstract_multi_map_map_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 665 static GeeAbstractMultiMapMapIterator* gee_abstract_multi_map_map_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 666 static GType gee_abstract_multi_map_mapping_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 667 static GType gee_abstract_multi_map_map_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 668 static GeeCollection* gee_abstract_multi_map_real_create_value_storage (GeeAbstractMultiMap* self);
 669 GeeMultiSet* gee_abstract_multi_map_create_multi_key_set (GeeAbstractMultiMap* self);
 670 static GeeMultiSet* gee_abstract_multi_map_real_create_multi_key_set (GeeAbstractMultiMap* self);
 671 GeeEqualDataFunc gee_abstract_multi_map_get_value_equal_func (GeeAbstractMultiMap* self, void** result_target, GDestroyNotify* result_target_destroy_notify);
 672 static GeeEqualDataFunc gee_abstract_multi_map_real_get_value_equal_func (GeeAbstractMultiMap* self, void** result_target, GDestroyNotify* result_target_destroy_notify);
 673 void gee_abstract_multi_map_reserved0 (GeeAbstractMultiMap* self);
 674 static void gee_abstract_multi_map_real_reserved0 (GeeAbstractMultiMap* self);
 675 void gee_abstract_multi_map_reserved1 (GeeAbstractMultiMap* self);
 676 static void gee_abstract_multi_map_real_reserved1 (GeeAbstractMultiMap* self);
 677 void gee_abstract_multi_map_reserved2 (GeeAbstractMultiMap* self);
 678 static void gee_abstract_multi_map_real_reserved2 (GeeAbstractMultiMap* self);
 679 void gee_abstract_multi_map_reserved3 (GeeAbstractMultiMap* self);
 680 static void gee_abstract_multi_map_real_reserved3 (GeeAbstractMultiMap* self);
 681 void gee_abstract_multi_map_reserved4 (GeeAbstractMultiMap* self);
 682 static void gee_abstract_multi_map_real_reserved4 (GeeAbstractMultiMap* self);
 683 void gee_abstract_multi_map_reserved5 (GeeAbstractMultiMap* self);
 684 static void gee_abstract_multi_map_real_reserved5 (GeeAbstractMultiMap* self);
 685 void gee_abstract_multi_map_reserved6 (GeeAbstractMultiMap* self);
 686 static void gee_abstract_multi_map_real_reserved6 (GeeAbstractMultiMap* self);
 687 void gee_abstract_multi_map_reserved7 (GeeAbstractMultiMap* self);
 688 static void gee_abstract_multi_map_real_reserved7 (GeeAbstractMultiMap* self);
 689 void gee_abstract_multi_map_reserved8 (GeeAbstractMultiMap* self);
 690 static void gee_abstract_multi_map_real_reserved8 (GeeAbstractMultiMap* self);
 691 GeeMultiMap* gee_abstract_multi_map_get_read_only_view (GeeAbstractMultiMap* self);
 692 GeeReadOnlyMultiMap* gee_read_only_multi_map_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMultiMap* multimap);
 693 GeeReadOnlyMultiMap* gee_read_only_multi_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, GeeMultiMap* multimap);
 694 GType gee_read_only_multi_map_get_type (void) G_GNUC_CONST;
 695 #define GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, GeeAbstractMultiMapAllKeysPrivate))
 696 enum  {
 697         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_DUMMY_PROPERTY,
 698         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_K_TYPE,
 699         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_K_DUP_FUNC,
 700         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_K_DESTROY_FUNC,
 701         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_V_TYPE,
 702         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_V_DUP_FUNC,
 703         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_V_DESTROY_FUNC,
 704         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_SIZE,
 705         GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_READ_ONLY
 706 };
 707 GeeAbstractCollection* gee_abstract_collection_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 708 static GeeIterator* gee_abstract_multi_map_all_keys_real_iterator (GeeAbstractCollection* base);
 709 static GeeAbstractMultiMapKeyIterator* gee_abstract_multi_map_key_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 710 static GeeAbstractMultiMapKeyIterator* gee_abstract_multi_map_key_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 711 static GType gee_abstract_multi_map_key_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 712 static gboolean gee_abstract_multi_map_all_keys_real_contains (GeeAbstractCollection* base, gconstpointer key);
 713 static gboolean gee_abstract_multi_map_all_keys_real_add (GeeAbstractCollection* base, gconstpointer key);
 714 static gboolean gee_abstract_multi_map_all_keys_real_remove (GeeAbstractCollection* base, gconstpointer item);
 715 static void gee_abstract_multi_map_all_keys_real_clear (GeeAbstractCollection* base);
 716 static gint gee_abstract_multi_map_all_keys_real_count (GeeMultiSet* base, gconstpointer item);
 717 gint gee_multi_map_get_size (GeeMultiMap* self);
 718 static void gee_abstract_multi_map_all_keys_finalize (GObject* obj);
 719 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 720 gboolean gee_abstract_collection_get_read_only (GeeAbstractCollection* self);
 721 static void _vala_gee_abstract_multi_map_all_keys_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 722 static void _vala_gee_abstract_multi_map_all_keys_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 723 #define GEE_ABSTRACT_MULTI_MAP_VALUES_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, GeeAbstractMultiMapValuesPrivate))
 724 enum  {
 725         GEE_ABSTRACT_MULTI_MAP_VALUES_DUMMY_PROPERTY,
 726         GEE_ABSTRACT_MULTI_MAP_VALUES_K_TYPE,
 727         GEE_ABSTRACT_MULTI_MAP_VALUES_K_DUP_FUNC,
 728         GEE_ABSTRACT_MULTI_MAP_VALUES_K_DESTROY_FUNC,
 729         GEE_ABSTRACT_MULTI_MAP_VALUES_V_TYPE,
 730         GEE_ABSTRACT_MULTI_MAP_VALUES_V_DUP_FUNC,
 731         GEE_ABSTRACT_MULTI_MAP_VALUES_V_DESTROY_FUNC,
 732         GEE_ABSTRACT_MULTI_MAP_VALUES_SIZE,
 733         GEE_ABSTRACT_MULTI_MAP_VALUES_READ_ONLY
 734 };
 735 static GeeIterator* gee_abstract_multi_map_values_real_iterator (GeeAbstractCollection* base);
 736 static GeeAbstractMultiMapValueIterator* gee_abstract_multi_map_value_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 737 static GeeAbstractMultiMapValueIterator* gee_abstract_multi_map_value_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 738 static GType gee_abstract_multi_map_value_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 739 static gboolean gee_abstract_multi_map_values_real_contains (GeeAbstractCollection* base, gconstpointer value);
 740 GeeCollection* gee_map_get_values (GeeMap* self);
 741 GeeIterator* gee_iterable_iterator (GeeIterable* self);
 742 gboolean gee_iterator_next (GeeIterator* self);
 743 gpointer gee_iterator_get (GeeIterator* self);
 744 static gboolean gee_abstract_multi_map_values_real_add (GeeAbstractCollection* base, gconstpointer key);
 745 static gboolean gee_abstract_multi_map_values_real_remove (GeeAbstractCollection* base, gconstpointer item);
 746 static void gee_abstract_multi_map_values_real_clear (GeeAbstractCollection* base);
 747 static void gee_abstract_multi_map_values_finalize (GObject* obj);
 748 static void _vala_gee_abstract_multi_map_values_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 749 static void _vala_gee_abstract_multi_map_values_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 750 #define GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, GeeAbstractMultiMapMappingIteratorPrivate))
 751 enum  {
 752         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_DUMMY_PROPERTY,
 753         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_TYPE,
 754         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_DUP_FUNC,
 755         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_DESTROY_FUNC,
 756         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_TYPE,
 757         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_DUP_FUNC,
 758         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_DESTROY_FUNC,
 759         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_READ_ONLY,
 760         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_VALID
 761 };
 762 static GeeAbstractMultiMapMappingIterator* gee_abstract_multi_map_mapping_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 763 static GeeAbstractMultiMapMappingIterator* gee_abstract_multi_map_mapping_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer);
 764 static gboolean gee_abstract_multi_map_mapping_iterator_next (GeeAbstractMultiMapMappingIterator* self);
 765 gboolean gee_map_iterator_next (GeeMapIterator* self);
 766 gpointer gee_map_iterator_get_value (GeeMapIterator* self);
 767 static gboolean gee_abstract_multi_map_mapping_iterator_has_next (GeeAbstractMultiMapMappingIterator* self);
 768 gboolean gee_iterator_has_next (GeeIterator* self);
 769 gboolean gee_map_iterator_has_next (GeeMapIterator* self);
 770 static void gee_abstract_multi_map_mapping_iterator_remove (GeeAbstractMultiMapMappingIterator* self);
 771 static void gee_abstract_multi_map_mapping_iterator_unset (GeeAbstractMultiMapMappingIterator* self);
 772 void gee_iterator_remove (GeeIterator* self);
 773 gboolean gee_collection_get_is_empty (GeeCollection* self);
 774 void gee_map_iterator_unset (GeeMapIterator* self);
 775 static gboolean gee_abstract_multi_map_mapping_iterator_get_read_only (GeeAbstractMultiMapMappingIterator* self);
 776 static gboolean gee_abstract_multi_map_mapping_iterator_get_valid (GeeAbstractMultiMapMappingIterator* self);
 777 gboolean gee_iterator_get_valid (GeeIterator* self);
 778 static void gee_abstract_multi_map_mapping_iterator_finalize (GObject* obj);
 779 static void _vala_gee_abstract_multi_map_mapping_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 780 static void _vala_gee_abstract_multi_map_mapping_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 781 #define GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR, GeeAbstractMultiMapKeyIteratorPrivate))
 782 enum  {
 783         GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_DUMMY_PROPERTY,
 784         GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_TYPE,
 785         GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_DUP_FUNC,
 786         GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_DESTROY_FUNC,
 787         GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_TYPE,
 788         GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_DUP_FUNC,
 789         GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_DESTROY_FUNC
 790 };
 791 static gpointer gee_abstract_multi_map_key_iterator_real_get (GeeIterator* base);
 792 gpointer gee_map_iterator_get_key (GeeMapIterator* self);
 793 static gboolean gee_abstract_multi_map_key_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 794 static Block1Data* block1_data_ref (Block1Data* _data1_);
 795 static void block1_data_unref (void * _userdata_);
 796 gboolean gee_map_iterator_get_valid (GeeMapIterator* self);
 797 static Block2Data* block2_data_ref (Block2Data* _data2_);
 798 static void block2_data_unref (void * _userdata_);
 799 gboolean gee_traversable_foreach (GeeTraversable* self, GeeForallFunc f, void* f_target);
 800 static gboolean ___lambda29_ (Block2Data* _data2_, gpointer v);
 801 static gboolean ____lambda29__gee_forall_func (gpointer g, gpointer self);
 802 gboolean gee_map_iterator_foreach (GeeMapIterator* self, GeeForallMapFunc f, void* f_target);
 803 static gboolean __lambda30_ (Block1Data* _data1_, gconstpointer key, GeeCollection* col);
 804 static Block3Data* block3_data_ref (Block3Data* _data3_);
 805 static void block3_data_unref (void * _userdata_);
 806 static gboolean __lambda31_ (Block3Data* _data3_, gpointer v);
 807 static gboolean ___lambda31__gee_forall_func (gpointer g, gpointer self);
 808 static gboolean ___lambda30__gee_forall_map_func (gconstpointer k, gconstpointer v, gpointer self);
 809 static void _vala_gee_abstract_multi_map_key_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 810 static void _vala_gee_abstract_multi_map_key_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 811 #define GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR, GeeAbstractMultiMapValueIteratorPrivate))
 812 enum  {
 813         GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_DUMMY_PROPERTY,
 814         GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_TYPE,
 815         GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_DUP_FUNC,
 816         GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_DESTROY_FUNC,
 817         GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_TYPE,
 818         GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_DUP_FUNC,
 819         GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_DESTROY_FUNC
 820 };
 821 static gpointer gee_abstract_multi_map_value_iterator_real_get (GeeIterator* base);
 822 static gboolean gee_abstract_multi_map_value_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 823 static Block4Data* block4_data_ref (Block4Data* _data4_);
 824 static void block4_data_unref (void * _userdata_);
 825 static gboolean __lambda32_ (Block4Data* _data4_, gconstpointer key, GeeCollection* col);
 826 static gboolean ___lambda32__gee_forall_map_func (gconstpointer k, gconstpointer v, gpointer self);
 827 static void _vala_gee_abstract_multi_map_value_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 828 static void _vala_gee_abstract_multi_map_value_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 829 #define GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR, GeeAbstractMultiMapMapIteratorPrivate))
 830 enum  {
 831         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_DUMMY_PROPERTY,
 832         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_TYPE,
 833         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_DUP_FUNC,
 834         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_DESTROY_FUNC,
 835         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_TYPE,
 836         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_DUP_FUNC,
 837         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_DESTROY_FUNC,
 838         GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_MUTABLE
 839 };
 840 static gpointer gee_abstract_multi_map_map_iterator_real_get_key (GeeMapIterator* base);
 841 static gpointer gee_abstract_multi_map_map_iterator_real_get_value (GeeMapIterator* base);
 842 static void gee_abstract_multi_map_map_iterator_real_set_value (GeeMapIterator* base, gconstpointer value);
 843 gboolean gee_map_iterator_get_mutable (GeeMapIterator* self);
 844 static void _vala_gee_abstract_multi_map_map_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 845 static void _vala_gee_abstract_multi_map_map_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 846 static void gee_abstract_multi_map_finalize (GObject* obj);
 847 gboolean gee_multi_map_get_read_only (GeeMultiMap* self);
 848 static void _vala_gee_abstract_multi_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 849 static void _vala_gee_abstract_multi_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 850
 851
 852 static gpointer _g_object_ref0 (gpointer self) {
 853         return self ? g_object_ref (self) : NULL;
 854 }
 855
 856
 857 GeeAbstractMultiMap* gee_abstract_multi_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMap* storage_map) {
 858         GeeAbstractMultiMap * self = NULL;
 859         GeeMap* _tmp0_;
 860         GeeMap* _tmp1_;
 861         g_return_val_if_fail (storage_map != NULL, NULL);
 862         self = (GeeAbstractMultiMap*) g_object_new (object_type, NULL);
 863         self->priv->k_type = k_type;
 864         self->priv->k_dup_func = k_dup_func;
 865         self->priv->k_destroy_func = k_destroy_func;
 866         self->priv->v_type = v_type;
 867         self->priv->v_dup_func = v_dup_func;
 868         self->priv->v_destroy_func = v_destroy_func;
 869         _tmp0_ = storage_map;
 870         _tmp1_ = _g_object_ref0 (_tmp0_);
 871         _g_object_unref0 (self->_storage_map);
 872         self->_storage_map = _tmp1_;
 873         return self;
 874 }
 875
 876
 877 static GeeSet* gee_abstract_multi_map_real_get_keys (GeeMultiMap* base) {
 878         GeeAbstractMultiMap * self;
 879         GeeSet* result = NULL;
 880         GeeMap* _tmp0_;
 881         GeeSet* _tmp1_;
 882         GeeSet* _tmp2_;
 883         self = (GeeAbstractMultiMap*) base;
 884         _tmp0_ = self->_storage_map;
 885         _tmp1_ = gee_map_get_keys (_tmp0_);
 886         _tmp2_ = _tmp1_;
 887         result = _tmp2_;
 888         return result;
 889 }
 890
 891
 892 static GeeMultiSet* gee_abstract_multi_map_real_get_all_keys (GeeMultiMap* base) {
 893         GeeAbstractMultiMap * self;
 894         GeeMultiSet* result = NULL;
 895         GeeAbstractMultiMapAllKeys* _tmp0_;
 896         self = (GeeAbstractMultiMap*) base;
 897         _tmp0_ = gee_abstract_multi_map_all_keys_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, self);
 898         result = (GeeMultiSet*) _tmp0_;
 899         return result;
 900 }
 901
 902
 903 static GeeCollection* gee_abstract_multi_map_real_get_values (GeeMultiMap* base) {
 904         GeeAbstractMultiMap * self;
 905         GeeCollection* result = NULL;
 906         GeeAbstractMultiMapValues* _tmp0_;
 907         self = (GeeAbstractMultiMap*) base;
 908         _tmp0_ = gee_abstract_multi_map_values_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, self);
 909         result = (GeeCollection*) _tmp0_;
 910         return result;
 911 }
 912
 913
 914 static gboolean gee_abstract_multi_map_real_contains (GeeMultiMap* base, gconstpointer key) {
 915         GeeAbstractMultiMap * self;
 916         gboolean result = FALSE;
 917         GeeMap* _tmp0_;
 918         gconstpointer _tmp1_;
 919         gboolean _tmp2_ = FALSE;
 920         self = (GeeAbstractMultiMap*) base;
 921         _tmp0_ = self->_storage_map;
 922         _tmp1_ = key;
 923         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
 924         result = _tmp2_;
 925         return result;
 926 }
 927
 928
 929 static GeeCollection* gee_abstract_multi_map_real_get (GeeMultiMap* base, gconstpointer key) {
 930         GeeAbstractMultiMap * self;
 931         GeeCollection* result = NULL;
 932         GeeMap* _tmp0_;
 933         gconstpointer _tmp1_;
 934         gpointer _tmp2_ = NULL;
 935         GeeCollection* col;
 936         GeeCollection* _tmp3_ = NULL;
 937         GeeCollection* _tmp4_;
 938         self = (GeeAbstractMultiMap*) base;
 939         _tmp0_ = self->_storage_map;
 940         _tmp1_ = key;
 941         _tmp2_ = gee_map_get (_tmp0_, _tmp1_);
 942         col = (GeeCollection*) _tmp2_;
 943         _tmp4_ = col;
 944         if (_tmp4_ != NULL) {
 945                 GeeCollection* _tmp5_;
 946                 GeeCollection* _tmp6_;
 947                 GeeCollection* _tmp7_;
 948                 _tmp5_ = col;
 949                 _tmp6_ = gee_collection_get_read_only_view (_tmp5_);
 950                 _tmp7_ = _tmp6_;
 951                 _g_object_unref0 (_tmp3_);
 952                 _tmp3_ = _tmp7_;
 953         } else {
 954                 GeeSet* _tmp8_ = NULL;
 955                 _tmp8_ = gee_set_empty (self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func);
 956                 _g_object_unref0 (_tmp3_);
 957                 _tmp3_ = (GeeCollection*) _tmp8_;
 958         }
 959         result = _tmp3_;
 960         _g_object_unref0 (col);
 961         return result;
 962 }
 963
 964
 965 static void gee_abstract_multi_map_real_set (GeeMultiMap* base, gconstpointer key, gconstpointer value) {
 966         GeeAbstractMultiMap * self;
 967         GeeMap* _tmp0_;
 968         gconstpointer _tmp1_;
 969         gboolean _tmp2_ = FALSE;
 970         self = (GeeAbstractMultiMap*) base;
 971         _tmp0_ = self->_storage_map;
 972         _tmp1_ = key;
 973         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
 974         if (_tmp2_) {
 975                 GeeMap* _tmp3_;
 976                 gconstpointer _tmp4_;
 977                 gpointer _tmp5_ = NULL;
 978                 GeeCollection* _tmp6_;
 979                 gconstpointer _tmp7_;
 980                 gboolean _tmp8_ = FALSE;
 981                 gboolean _tmp9_;
 982                 _tmp3_ = self->_storage_map;
 983                 _tmp4_ = key;
 984                 _tmp5_ = gee_map_get (_tmp3_, _tmp4_);
 985                 _tmp6_ = (GeeCollection*) _tmp5_;
 986                 _tmp7_ = value;
 987                 _tmp8_ = gee_collection_add (_tmp6_, _tmp7_);
 988                 _tmp9_ = _tmp8_;
 989                 _g_object_unref0 (_tmp6_);
 990                 if (_tmp9_) {
 991                         gint _tmp10_;
 992                         _tmp10_ = self->priv->_nitems;
 993                         self->priv->_nitems = _tmp10_ + 1;
 994                 }
 995         } else {
 996                 GeeCollection* _tmp11_ = NULL;
 997                 GeeCollection* s;
 998                 GeeCollection* _tmp12_;
 999                 gconstpointer _tmp13_;
1000                 GeeMap* _tmp14_;
1001                 gconstpointer _tmp15_;
1002                 GeeCollection* _tmp16_;
1003                 gint _tmp17_;
1004                 _tmp11_ = gee_abstract_multi_map_create_value_storage (self);
1005                 s = _tmp11_;
1006                 _tmp12_ = s;
1007                 _tmp13_ = value;
1008                 gee_collection_add (_tmp12_, _tmp13_);
1009                 _tmp14_ = self->_storage_map;
1010                 _tmp15_ = key;
1011                 _tmp16_ = s;
1012                 gee_map_set (_tmp14_, _tmp15_, _tmp16_);
1013                 _tmp17_ = self->priv->_nitems;
1014                 self->priv->_nitems = _tmp17_ + 1;
1015                 _g_object_unref0 (s);
1016         }
1017 }
1018
1019
1020 static gboolean gee_abstract_multi_map_real_remove (GeeMultiMap* base, gconstpointer key, gconstpointer value) {
1021         GeeAbstractMultiMap * self;
1022         gboolean result = FALSE;
1023         GeeMap* _tmp0_;
1024         gconstpointer _tmp1_;
1025         gboolean _tmp2_ = FALSE;
1026         self = (GeeAbstractMultiMap*) base;
1027         _tmp0_ = self->_storage_map;
1028         _tmp1_ = key;
1029         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
1030         if (_tmp2_) {
1031                 GeeMap* _tmp3_;
1032                 gconstpointer _tmp4_;
1033                 gpointer _tmp5_ = NULL;
1034                 GeeCollection* values;
1035                 GeeCollection* _tmp6_;
1036                 gconstpointer _tmp7_;
1037                 gboolean _tmp8_ = FALSE;
1038                 _tmp3_ = self->_storage_map;
1039                 _tmp4_ = key;
1040                 _tmp5_ = gee_map_get (_tmp3_, _tmp4_);
1041                 values = (GeeCollection*) _tmp5_;
1042                 _tmp6_ = values;
1043                 _tmp7_ = value;
1044                 _tmp8_ = gee_collection_contains (_tmp6_, _tmp7_);
1045                 if (_tmp8_) {
1046                         GeeCollection* _tmp9_;
1047                         gconstpointer _tmp10_;
1048                         gint _tmp11_;
1049                         GeeCollection* _tmp12_;
1050                         gint _tmp13_;
1051                         gint _tmp14_;
1052                         _tmp9_ = values;
1053                         _tmp10_ = value;
1054                         gee_collection_remove (_tmp9_, _tmp10_);
1055                         _tmp11_ = self->priv->_nitems;
1056                         self->priv->_nitems = _tmp11_ - 1;
1057                         _tmp12_ = values;
1058                         _tmp13_ = gee_collection_get_size (_tmp12_);
1059                         _tmp14_ = _tmp13_;
1060                         if (_tmp14_ == 0) {
1061                                 GeeMap* _tmp15_;
1062                                 gconstpointer _tmp16_;
1063                                 _tmp15_ = self->_storage_map;
1064                                 _tmp16_ = key;
1065                                 gee_map_unset (_tmp15_, _tmp16_, NULL);
1066                         }
1067                         result = TRUE;
1068                         _g_object_unref0 (values);
1069                         return result;
1070                 }
1071                 _g_object_unref0 (values);
1072         }
1073         result = FALSE;
1074         return result;
1075 }
1076
1077
1078 static gboolean gee_abstract_multi_map_real_remove_all (GeeMultiMap* base, gconstpointer key) {
1079         GeeAbstractMultiMap * self;
1080         gboolean result = FALSE;
1081         GeeMap* _tmp0_;
1082         gconstpointer _tmp1_;
1083         gboolean _tmp2_ = FALSE;
1084         self = (GeeAbstractMultiMap*) base;
1085         _tmp0_ = self->_storage_map;
1086         _tmp1_ = key;
1087         _tmp2_ = gee_map_has_key (_tmp0_, _tmp1_);
1088         if (_tmp2_) {
1089                 GeeMap* _tmp3_;
1090                 gconstpointer _tmp4_;
1091                 gpointer _tmp5_ = NULL;
1092                 GeeCollection* _tmp6_;
1093                 gint _tmp7_;
1094                 gint _tmp8_;
1095                 gint _tmp9_;
1096                 gint size;
1097                 GeeMap* _tmp10_;
1098                 gconstpointer _tmp11_;
1099                 gboolean _tmp12_ = FALSE;
1100                 _tmp3_ = self->_storage_map;
1101                 _tmp4_ = key;
1102                 _tmp5_ = gee_map_get (_tmp3_, _tmp4_);
1103                 _tmp6_ = (GeeCollection*) _tmp5_;
1104                 _tmp7_ = gee_collection_get_size (_tmp6_);
1105                 _tmp8_ = _tmp7_;
1106                 _tmp9_ = _tmp8_;
1107                 _g_object_unref0 (_tmp6_);
1108                 size = _tmp9_;
1109                 _tmp10_ = self->_storage_map;
1110                 _tmp11_ = key;
1111                 _tmp12_ = gee_map_unset (_tmp10_, _tmp11_, NULL);
1112                 if (_tmp12_) {
1113                         gint _tmp13_;
1114                         gint _tmp14_;
1115                         _tmp13_ = self->priv->_nitems;
1116                         _tmp14_ = size;
1117                         self->priv->_nitems = _tmp13_ - _tmp14_;
1118                         result = TRUE;
1119                         return result;
1120                 }
1121         }
1122         result = FALSE;
1123         return result;
1124 }
1125
1126
1127 static void gee_abstract_multi_map_real_clear (GeeMultiMap* base) {
1128         GeeAbstractMultiMap * self;
1129         GeeMap* _tmp0_;
1130         self = (GeeAbstractMultiMap*) base;
1131         _tmp0_ = self->_storage_map;
1132         gee_map_clear (_tmp0_);
1133         self->priv->_nitems = 0;
1134 }
1135
1136
1137 static GeeMapIterator* gee_abstract_multi_map_real_map_iterator (GeeMultiMap* base) {
1138         GeeAbstractMultiMap * self;
1139         GeeMapIterator* result = NULL;
1140         GeeMap* _tmp0_;
1141         GeeMapIterator* _tmp1_ = NULL;
1142         GeeMapIterator* _tmp2_;
1143         GeeAbstractMultiMapMapIterator* _tmp3_;
1144         GeeMapIterator* _tmp4_;
1145         self = (GeeAbstractMultiMap*) base;
1146         _tmp0_ = self->_storage_map;
1147         _tmp1_ = gee_map_map_iterator (_tmp0_);
1148         _tmp2_ = _tmp1_;
1149         _tmp3_ = gee_abstract_multi_map_map_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp2_);
1150         _tmp4_ = (GeeMapIterator*) _tmp3_;
1151         _g_object_unref0 (_tmp2_);
1152         result = _tmp4_;
1153         return result;
1154 }
1155
1156
1157 static GeeCollection* gee_abstract_multi_map_real_create_value_storage (GeeAbstractMultiMap* self) {
1158         g_critical ("Type `%s' does not implement abstract method `gee_abstract_multi_map_create_value_storage'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1159         return NULL;
1160 }
1161
1162
1163 GeeCollection* gee_abstract_multi_map_create_value_storage (GeeAbstractMultiMap* self) {
1164         g_return_val_if_fail (self != NULL, NULL);
1165         return GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->create_value_storage (self);
1166 }
1167
1168
1169 static GeeMultiSet* gee_abstract_multi_map_real_create_multi_key_set (GeeAbstractMultiMap* self) {
1170         g_critical ("Type `%s' does not implement abstract method `gee_abstract_multi_map_create_multi_key_set'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1171         return NULL;
1172 }
1173
1174
1175 GeeMultiSet* gee_abstract_multi_map_create_multi_key_set (GeeAbstractMultiMap* self) {
1176         g_return_val_if_fail (self != NULL, NULL);
1177         return GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->create_multi_key_set (self);
1178 }
1179
1180
1181 static GeeEqualDataFunc gee_abstract_multi_map_real_get_value_equal_func (GeeAbstractMultiMap* self, void** result_target, GDestroyNotify* result_target_destroy_notify) {
1182         g_critical ("Type `%s' does not implement abstract method `gee_abstract_multi_map_get_value_equal_func'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
1183         return NULL;
1184 }
1185
1186
1187 GeeEqualDataFunc gee_abstract_multi_map_get_value_equal_func (GeeAbstractMultiMap* self, void** result_target, GDestroyNotify* result_target_destroy_notify) {
1188         g_return_val_if_fail (self != NULL, NULL);
1189         return GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->get_value_equal_func (self, result_target, result_target_destroy_notify);
1190 }
1191
1192
1193 static void gee_abstract_multi_map_real_reserved0 (GeeAbstractMultiMap* self) {
1194 }
1195
1196
1197 void gee_abstract_multi_map_reserved0 (GeeAbstractMultiMap* self) {
1198         g_return_if_fail (self != NULL);
1199         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved0 (self);
1200 }
1201
1202
1203 static void gee_abstract_multi_map_real_reserved1 (GeeAbstractMultiMap* self) {
1204 }
1205
1206
1207 void gee_abstract_multi_map_reserved1 (GeeAbstractMultiMap* self) {
1208         g_return_if_fail (self != NULL);
1209         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved1 (self);
1210 }
1211
1212
1213 static void gee_abstract_multi_map_real_reserved2 (GeeAbstractMultiMap* self) {
1214 }
1215
1216
1217 void gee_abstract_multi_map_reserved2 (GeeAbstractMultiMap* self) {
1218         g_return_if_fail (self != NULL);
1219         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved2 (self);
1220 }
1221
1222
1223 static void gee_abstract_multi_map_real_reserved3 (GeeAbstractMultiMap* self) {
1224 }
1225
1226
1227 void gee_abstract_multi_map_reserved3 (GeeAbstractMultiMap* self) {
1228         g_return_if_fail (self != NULL);
1229         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved3 (self);
1230 }
1231
1232
1233 static void gee_abstract_multi_map_real_reserved4 (GeeAbstractMultiMap* self) {
1234 }
1235
1236
1237 void gee_abstract_multi_map_reserved4 (GeeAbstractMultiMap* self) {
1238         g_return_if_fail (self != NULL);
1239         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved4 (self);
1240 }
1241
1242
1243 static void gee_abstract_multi_map_real_reserved5 (GeeAbstractMultiMap* self) {
1244 }
1245
1246
1247 void gee_abstract_multi_map_reserved5 (GeeAbstractMultiMap* self) {
1248         g_return_if_fail (self != NULL);
1249         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved5 (self);
1250 }
1251
1252
1253 static void gee_abstract_multi_map_real_reserved6 (GeeAbstractMultiMap* self) {
1254 }
1255
1256
1257 void gee_abstract_multi_map_reserved6 (GeeAbstractMultiMap* self) {
1258         g_return_if_fail (self != NULL);
1259         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved6 (self);
1260 }
1261
1262
1263 static void gee_abstract_multi_map_real_reserved7 (GeeAbstractMultiMap* self) {
1264 }
1265
1266
1267 void gee_abstract_multi_map_reserved7 (GeeAbstractMultiMap* self) {
1268         g_return_if_fail (self != NULL);
1269         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved7 (self);
1270 }
1271
1272
1273 static void gee_abstract_multi_map_real_reserved8 (GeeAbstractMultiMap* self) {
1274 }
1275
1276
1277 void gee_abstract_multi_map_reserved8 (GeeAbstractMultiMap* self) {
1278         g_return_if_fail (self != NULL);
1279         GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->reserved8 (self);
1280 }
1281
1282
1283 static gint gee_abstract_multi_map_real_get_size (GeeMultiMap* base) {
1284         gint result;
1285         GeeAbstractMultiMap* self;
1286         gint _tmp0_;
1287         self = (GeeAbstractMultiMap*) base;
1288         _tmp0_ = self->priv->_nitems;
1289         result = _tmp0_;
1290         return result;
1291 }
1292
1293
1294 static gboolean gee_abstract_multi_map_real_get_read_only (GeeMultiMap* base) {
1295         gboolean result;
1296         GeeAbstractMultiMap* self;
1297         self = (GeeAbstractMultiMap*) base;
1298         result = FALSE;
1299         return result;
1300 }
1301
1302
1303 GeeMultiMap* gee_abstract_multi_map_get_read_only_view (GeeAbstractMultiMap* self) {
1304         g_return_val_if_fail (self != NULL, NULL);
1305         return GEE_ABSTRACT_MULTI_MAP_GET_CLASS (self)->get_read_only_view (self);
1306 }
1307
1308
1309 static GeeMultiMap* gee_abstract_multi_map_real_get_read_only_view (GeeAbstractMultiMap* base) {
1310         GeeMultiMap* result;
1311         GeeAbstractMultiMap* self;
1312         GeeMultiMap* _tmp0_;
1313         GeeMultiMap* _tmp1_;
1314         GeeMultiMap* instance;
1315         GeeMultiMap* _tmp2_;
1316         self = base;
1317         _tmp0_ = self->priv->_read_only_view;
1318         _tmp1_ = _g_object_ref0 (_tmp0_);
1319         instance = _tmp1_;
1320         _tmp2_ = self->priv->_read_only_view;
1321         if (_tmp2_ == NULL) {
1322                 GeeReadOnlyMultiMap* _tmp3_;
1323                 GeeMultiMap* _tmp4_;
1324                 GeeMultiMap* _tmp5_;
1325                 _tmp3_ = gee_read_only_multi_map_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, (GeeMultiMap*) self);
1326                 _g_object_unref0 (instance);
1327                 instance = (GeeMultiMap*) _tmp3_;
1328                 _tmp4_ = instance;
1329                 self->priv->_read_only_view = _tmp4_;
1330                 _tmp5_ = instance;
1331                 g_object_add_weak_pointer ((GObject*) _tmp5_, (void**) (&self->priv->_read_only_view));
1332         }
1333         result = instance;
1334         return result;
1335 }
1336
1337
1338 static GeeAbstractMultiMapAllKeys* gee_abstract_multi_map_all_keys_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, GeeAbstractMultiMap* multi_map) {
1339         GeeAbstractMultiMapAllKeys * self = NULL;
1340         GeeAbstractMultiMap* _tmp0_;
1341         GeeAbstractMultiMap* _tmp1_;
1342         g_return_val_if_fail (multi_map != NULL, NULL);
1343         self = (GeeAbstractMultiMapAllKeys*) gee_abstract_collection_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func);
1344         self->priv->k_type = k_type;
1345         self->priv->k_dup_func = k_dup_func;
1346         self->priv->k_destroy_func = k_destroy_func;
1347         self->priv->v_type = v_type;
1348         self->priv->v_dup_func = v_dup_func;
1349         self->priv->v_destroy_func = v_destroy_func;
1350         _tmp0_ = multi_map;
1351         _tmp1_ = _g_object_ref0 (_tmp0_);
1352         _g_object_unref0 (self->_multi_map);
1353         self->_multi_map = _tmp1_;
1354         return self;
1355 }
1356
1357
1358 static GeeAbstractMultiMapAllKeys* gee_abstract_multi_map_all_keys_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeAbstractMultiMap* multi_map) {
1359         return gee_abstract_multi_map_all_keys_construct (GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, multi_map);
1360 }
1361
1362
1363 static GeeIterator* gee_abstract_multi_map_all_keys_real_iterator (GeeAbstractCollection* base) {
1364         GeeAbstractMultiMapAllKeys * self;
1365         GeeIterator* result = NULL;
1366         GeeAbstractMultiMap* _tmp0_;
1367         GeeMap* _tmp1_;
1368         GeeMapIterator* _tmp2_ = NULL;
1369         GeeMapIterator* _tmp3_;
1370         GeeAbstractMultiMapKeyIterator* _tmp4_;
1371         GeeIterator* _tmp5_;
1372         self = (GeeAbstractMultiMapAllKeys*) base;
1373         _tmp0_ = self->_multi_map;
1374         _tmp1_ = _tmp0_->_storage_map;
1375         _tmp2_ = gee_map_map_iterator (_tmp1_);
1376         _tmp3_ = _tmp2_;
1377         _tmp4_ = gee_abstract_multi_map_key_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp3_);
1378         _tmp5_ = (GeeIterator*) _tmp4_;
1379         _g_object_unref0 (_tmp3_);
1380         result = _tmp5_;
1381         return result;
1382 }
1383
1384
1385 static gboolean gee_abstract_multi_map_all_keys_real_contains (GeeAbstractCollection* base, gconstpointer key) {
1386         GeeAbstractMultiMapAllKeys * self;
1387         gboolean result = FALSE;
1388         GeeAbstractMultiMap* _tmp0_;
1389         GeeMap* _tmp1_;
1390         gconstpointer _tmp2_;
1391         gboolean _tmp3_ = FALSE;
1392         self = (GeeAbstractMultiMapAllKeys*) base;
1393         _tmp0_ = self->_multi_map;
1394         _tmp1_ = _tmp0_->_storage_map;
1395         _tmp2_ = key;
1396         _tmp3_ = gee_map_has_key (_tmp1_, _tmp2_);
1397         result = _tmp3_;
1398         return result;
1399 }
1400
1401
1402 static gboolean gee_abstract_multi_map_all_keys_real_add (GeeAbstractCollection* base, gconstpointer key) {
1403         GeeAbstractMultiMapAllKeys * self;
1404         gboolean result = FALSE;
1405         self = (GeeAbstractMultiMapAllKeys*) base;
1406         g_assert_not_reached ();
1407         return result;
1408 }
1409
1410
1411 static gboolean gee_abstract_multi_map_all_keys_real_remove (GeeAbstractCollection* base, gconstpointer item) {
1412         GeeAbstractMultiMapAllKeys * self;
1413         gboolean result = FALSE;
1414         self = (GeeAbstractMultiMapAllKeys*) base;
1415         g_assert_not_reached ();
1416         return result;
1417 }
1418
1419
1420 static void gee_abstract_multi_map_all_keys_real_clear (GeeAbstractCollection* base) {
1421         GeeAbstractMultiMapAllKeys * self;
1422         self = (GeeAbstractMultiMapAllKeys*) base;
1423         g_assert_not_reached ();
1424 }
1425
1426
1427 static gint gee_abstract_multi_map_all_keys_real_count (GeeMultiSet* base, gconstpointer item) {
1428         GeeAbstractMultiMapAllKeys * self;
1429         gint result = 0;
1430         GeeAbstractMultiMap* _tmp0_;
1431         GeeMap* _tmp1_;
1432         gconstpointer _tmp2_;
1433         gpointer _tmp3_ = NULL;
1434         GeeCollection* collection;
1435         gint _tmp4_ = 0;
1436         GeeCollection* _tmp5_;
1437         gint _tmp9_;
1438         self = (GeeAbstractMultiMapAllKeys*) base;
1439         _tmp0_ = self->_multi_map;
1440         _tmp1_ = _tmp0_->_storage_map;
1441         _tmp2_ = item;
1442         _tmp3_ = gee_map_get (_tmp1_, _tmp2_);
1443         collection = (GeeCollection*) _tmp3_;
1444         _tmp5_ = collection;
1445         if (_tmp5_ != NULL) {
1446                 GeeCollection* _tmp6_;
1447                 gint _tmp7_;
1448                 gint _tmp8_;
1449                 _tmp6_ = collection;
1450                 _tmp7_ = gee_collection_get_size (_tmp6_);
1451                 _tmp8_ = _tmp7_;
1452                 _tmp4_ = _tmp8_;
1453         } else {
1454                 _tmp4_ = 0;
1455         }
1456         _tmp9_ = _tmp4_;
1457         result = _tmp9_;
1458         _g_object_unref0 (collection);
1459         return result;
1460 }
1461
1462
1463 static gint gee_abstract_multi_map_all_keys_real_get_size (GeeAbstractCollection* base) {
1464         gint result;
1465         GeeAbstractMultiMapAllKeys* self;
1466         GeeAbstractMultiMap* _tmp0_;
1467         gint _tmp1_;
1468         gint _tmp2_;
1469         self = (GeeAbstractMultiMapAllKeys*) base;
1470         _tmp0_ = self->_multi_map;
1471         _tmp1_ = gee_multi_map_get_size ((GeeMultiMap*) _tmp0_);
1472         _tmp2_ = _tmp1_;
1473         result = _tmp2_;
1474         return result;
1475 }
1476
1477
1478 static gboolean gee_abstract_multi_map_all_keys_real_get_read_only (GeeAbstractCollection* base) {
1479         gboolean result;
1480         GeeAbstractMultiMapAllKeys* self;
1481         self = (GeeAbstractMultiMapAllKeys*) base;
1482         result = TRUE;
1483         return result;
1484 }
1485
1486
1487 static void gee_abstract_multi_map_all_keys_class_init (GeeAbstractMultiMapAllKeysClass * klass) {
1488         gee_abstract_multi_map_all_keys_parent_class = g_type_class_peek_parent (klass);
1489         g_type_class_add_private (klass, sizeof (GeeAbstractMultiMapAllKeysPrivate));
1490         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_abstract_multi_map_all_keys_real_iterator;
1491         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_abstract_multi_map_all_keys_real_contains;
1492         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_abstract_multi_map_all_keys_real_add;
1493         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_abstract_multi_map_all_keys_real_remove;
1494         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_abstract_multi_map_all_keys_real_clear;
1495         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_abstract_multi_map_all_keys_real_get_size;
1496         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_abstract_multi_map_all_keys_real_get_read_only;
1497         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_map_all_keys_get_property;
1498         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_map_all_keys_set_property;
1499         G_OBJECT_CLASS (klass)->finalize = gee_abstract_multi_map_all_keys_finalize;
1500         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1501         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1502         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1503         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1504         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1505         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1506         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1507         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_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));
1508 }
1509
1510
1511 static GType gee_abstract_multi_map_all_keys_gee_multi_set_get_g_type (GeeAbstractMultiMapAllKeys* self) {
1512         return self->priv->k_type;
1513 }
1514
1515
1516 static GBoxedCopyFunc gee_abstract_multi_map_all_keys_gee_multi_set_get_g_dup_func (GeeAbstractMultiMapAllKeys* self) {
1517         return self->priv->k_dup_func;
1518 }
1519
1520
1521 static GDestroyNotify gee_abstract_multi_map_all_keys_gee_multi_set_get_g_destroy_func (GeeAbstractMultiMapAllKeys* self) {
1522         return self->priv->k_destroy_func;
1523 }
1524
1525
1526 static void gee_abstract_multi_map_all_keys_gee_multi_set_interface_init (GeeMultiSetIface * iface) {
1527         gee_abstract_multi_map_all_keys_gee_multi_set_parent_iface = g_type_interface_peek_parent (iface);
1528         iface->count = (gint (*)(GeeMultiSet*, gconstpointer)) gee_abstract_multi_map_all_keys_real_count;
1529         iface->get_g_type = (GType(*)(GeeMultiSet*)) gee_abstract_multi_map_all_keys_gee_multi_set_get_g_type;
1530         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeMultiSet*)) gee_abstract_multi_map_all_keys_gee_multi_set_get_g_dup_func;
1531         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeMultiSet*)) gee_abstract_multi_map_all_keys_gee_multi_set_get_g_destroy_func;
1532 }
1533
1534
1535 static void gee_abstract_multi_map_all_keys_instance_init (GeeAbstractMultiMapAllKeys * self) {
1536         self->priv = GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_GET_PRIVATE (self);
1537 }
1538
1539
1540 static void gee_abstract_multi_map_all_keys_finalize (GObject* obj) {
1541         GeeAbstractMultiMapAllKeys * self;
1542         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, GeeAbstractMultiMapAllKeys);
1543         _g_object_unref0 (self->_multi_map);
1544         G_OBJECT_CLASS (gee_abstract_multi_map_all_keys_parent_class)->finalize (obj);
1545 }
1546
1547
1548 static GType gee_abstract_multi_map_all_keys_get_type (void) {
1549         static volatile gsize gee_abstract_multi_map_all_keys_type_id__volatile = 0;
1550         if (g_once_init_enter (&gee_abstract_multi_map_all_keys_type_id__volatile)) {
1551                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiMapAllKeysClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_map_all_keys_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiMapAllKeys), 0, (GInstanceInitFunc) gee_abstract_multi_map_all_keys_instance_init, NULL };
1552                 static const GInterfaceInfo gee_multi_set_info = { (GInterfaceInitFunc) gee_abstract_multi_map_all_keys_gee_multi_set_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1553                 GType gee_abstract_multi_map_all_keys_type_id;
1554                 gee_abstract_multi_map_all_keys_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_COLLECTION, "GeeAbstractMultiMapAllKeys", &g_define_type_info, 0);
1555                 g_type_add_interface_static (gee_abstract_multi_map_all_keys_type_id, GEE_TYPE_MULTI_SET, &gee_multi_set_info);
1556                 g_once_init_leave (&gee_abstract_multi_map_all_keys_type_id__volatile, gee_abstract_multi_map_all_keys_type_id);
1557         }
1558         return gee_abstract_multi_map_all_keys_type_id__volatile;
1559 }
1560
1561
1562 static void _vala_gee_abstract_multi_map_all_keys_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1563         GeeAbstractMultiMapAllKeys * self;
1564         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, GeeAbstractMultiMapAllKeys);
1565         switch (property_id) {
1566                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_SIZE:
1567                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
1568                 break;
1569                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_READ_ONLY:
1570                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
1571                 break;
1572                 default:
1573                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1574                 break;
1575         }
1576 }
1577
1578
1579 static void _vala_gee_abstract_multi_map_all_keys_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1580         GeeAbstractMultiMapAllKeys * self;
1581         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_ALL_KEYS, GeeAbstractMultiMapAllKeys);
1582         switch (property_id) {
1583                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_K_TYPE:
1584                 self->priv->k_type = g_value_get_gtype (value);
1585                 break;
1586                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_K_DUP_FUNC:
1587                 self->priv->k_dup_func = g_value_get_pointer (value);
1588                 break;
1589                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_K_DESTROY_FUNC:
1590                 self->priv->k_destroy_func = g_value_get_pointer (value);
1591                 break;
1592                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_V_TYPE:
1593                 self->priv->v_type = g_value_get_gtype (value);
1594                 break;
1595                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_V_DUP_FUNC:
1596                 self->priv->v_dup_func = g_value_get_pointer (value);
1597                 break;
1598                 case GEE_ABSTRACT_MULTI_MAP_ALL_KEYS_V_DESTROY_FUNC:
1599                 self->priv->v_destroy_func = g_value_get_pointer (value);
1600                 break;
1601                 default:
1602                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1603                 break;
1604         }
1605 }
1606
1607
1608 static GeeAbstractMultiMapValues* gee_abstract_multi_map_values_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, GeeAbstractMultiMap* multi_map) {
1609         GeeAbstractMultiMapValues * self = NULL;
1610         GeeAbstractMultiMap* _tmp0_;
1611         GeeAbstractMultiMap* _tmp1_;
1612         g_return_val_if_fail (multi_map != NULL, NULL);
1613         self = (GeeAbstractMultiMapValues*) gee_abstract_collection_construct (object_type, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func);
1614         self->priv->k_type = k_type;
1615         self->priv->k_dup_func = k_dup_func;
1616         self->priv->k_destroy_func = k_destroy_func;
1617         self->priv->v_type = v_type;
1618         self->priv->v_dup_func = v_dup_func;
1619         self->priv->v_destroy_func = v_destroy_func;
1620         _tmp0_ = multi_map;
1621         _tmp1_ = _g_object_ref0 (_tmp0_);
1622         _g_object_unref0 (self->_multi_map);
1623         self->_multi_map = _tmp1_;
1624         return self;
1625 }
1626
1627
1628 static GeeAbstractMultiMapValues* gee_abstract_multi_map_values_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeAbstractMultiMap* multi_map) {
1629         return gee_abstract_multi_map_values_construct (GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, multi_map);
1630 }
1631
1632
1633 static GeeIterator* gee_abstract_multi_map_values_real_iterator (GeeAbstractCollection* base) {
1634         GeeAbstractMultiMapValues * self;
1635         GeeIterator* result = NULL;
1636         GeeAbstractMultiMap* _tmp0_;
1637         GeeMap* _tmp1_;
1638         GeeMapIterator* _tmp2_ = NULL;
1639         GeeMapIterator* _tmp3_;
1640         GeeAbstractMultiMapValueIterator* _tmp4_;
1641         GeeIterator* _tmp5_;
1642         self = (GeeAbstractMultiMapValues*) base;
1643         _tmp0_ = self->_multi_map;
1644         _tmp1_ = _tmp0_->_storage_map;
1645         _tmp2_ = gee_map_map_iterator (_tmp1_);
1646         _tmp3_ = _tmp2_;
1647         _tmp4_ = gee_abstract_multi_map_value_iterator_new (self->priv->k_type, (GBoxedCopyFunc) self->priv->k_dup_func, self->priv->k_destroy_func, self->priv->v_type, (GBoxedCopyFunc) self->priv->v_dup_func, self->priv->v_destroy_func, _tmp3_);
1648         _tmp5_ = (GeeIterator*) _tmp4_;
1649         _g_object_unref0 (_tmp3_);
1650         result = _tmp5_;
1651         return result;
1652 }
1653
1654
1655 static gboolean gee_abstract_multi_map_values_real_contains (GeeAbstractCollection* base, gconstpointer value) {
1656         GeeAbstractMultiMapValues * self;
1657         gboolean result = FALSE;
1658         self = (GeeAbstractMultiMapValues*) base;
1659         {
1660                 GeeAbstractMultiMap* _tmp0_;
1661                 GeeMap* _tmp1_;
1662                 GeeCollection* _tmp2_;
1663                 GeeCollection* _tmp3_;
1664                 GeeCollection* _tmp4_;
1665                 GeeIterator* _tmp5_ = NULL;
1666                 GeeIterator* _tmp6_;
1667                 GeeIterator* _col_it;
1668                 _tmp0_ = self->_multi_map;
1669                 _tmp1_ = _tmp0_->_storage_map;
1670                 _tmp2_ = gee_map_get_values (_tmp1_);
1671                 _tmp3_ = _tmp2_;
1672                 _tmp4_ = _tmp3_;
1673                 _tmp5_ = gee_iterable_iterator ((GeeIterable*) _tmp4_);
1674                 _tmp6_ = _tmp5_;
1675                 _g_object_unref0 (_tmp4_);
1676                 _col_it = _tmp6_;
1677                 while (TRUE) {
1678                         GeeIterator* _tmp7_;
1679                         gboolean _tmp8_ = FALSE;
1680                         GeeIterator* _tmp9_;
1681                         gpointer _tmp10_ = NULL;
1682                         GeeCollection* col;
1683                         GeeCollection* _tmp11_;
1684                         gconstpointer _tmp12_;
1685                         gboolean _tmp13_ = FALSE;
1686                         _tmp7_ = _col_it;
1687                         _tmp8_ = gee_iterator_next (_tmp7_);
1688                         if (!_tmp8_) {
1689                                 break;
1690                         }
1691                         _tmp9_ = _col_it;
1692                         _tmp10_ = gee_iterator_get (_tmp9_);
1693                         col = (GeeCollection*) _tmp10_;
1694                         _tmp11_ = col;
1695                         _tmp12_ = value;
1696                         _tmp13_ = gee_collection_contains (_tmp11_, _tmp12_);
1697                         if (_tmp13_) {
1698                                 result = TRUE;
1699                                 _g_object_unref0 (col);
1700                                 _g_object_unref0 (_col_it);
1701                                 return result;
1702                         }
1703                         _g_object_unref0 (col);
1704                 }
1705                 _g_object_unref0 (_col_it);
1706         }
1707         result = FALSE;
1708         return result;
1709 }
1710
1711
1712 static gboolean gee_abstract_multi_map_values_real_add (GeeAbstractCollection* base, gconstpointer key) {
1713         GeeAbstractMultiMapValues * self;
1714         gboolean result = FALSE;
1715         self = (GeeAbstractMultiMapValues*) base;
1716         g_assert_not_reached ();
1717         return result;
1718 }
1719
1720
1721 static gboolean gee_abstract_multi_map_values_real_remove (GeeAbstractCollection* base, gconstpointer item) {
1722         GeeAbstractMultiMapValues * self;
1723         gboolean result = FALSE;
1724         self = (GeeAbstractMultiMapValues*) base;
1725         g_assert_not_reached ();
1726         return result;
1727 }
1728
1729
1730 static void gee_abstract_multi_map_values_real_clear (GeeAbstractCollection* base) {
1731         GeeAbstractMultiMapValues * self;
1732         self = (GeeAbstractMultiMapValues*) base;
1733         g_assert_not_reached ();
1734 }
1735
1736
1737 static gint gee_abstract_multi_map_values_real_get_size (GeeAbstractCollection* base) {
1738         gint result;
1739         GeeAbstractMultiMapValues* self;
1740         GeeAbstractMultiMap* _tmp0_;
1741         gint _tmp1_;
1742         gint _tmp2_;
1743         self = (GeeAbstractMultiMapValues*) base;
1744         _tmp0_ = self->_multi_map;
1745         _tmp1_ = gee_multi_map_get_size ((GeeMultiMap*) _tmp0_);
1746         _tmp2_ = _tmp1_;
1747         result = _tmp2_;
1748         return result;
1749 }
1750
1751
1752 static gboolean gee_abstract_multi_map_values_real_get_read_only (GeeAbstractCollection* base) {
1753         gboolean result;
1754         GeeAbstractMultiMapValues* self;
1755         self = (GeeAbstractMultiMapValues*) base;
1756         result = TRUE;
1757         return result;
1758 }
1759
1760
1761 static void gee_abstract_multi_map_values_class_init (GeeAbstractMultiMapValuesClass * klass) {
1762         gee_abstract_multi_map_values_parent_class = g_type_class_peek_parent (klass);
1763         g_type_class_add_private (klass, sizeof (GeeAbstractMultiMapValuesPrivate));
1764         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_abstract_multi_map_values_real_iterator;
1765         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_abstract_multi_map_values_real_contains;
1766         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_abstract_multi_map_values_real_add;
1767         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_abstract_multi_map_values_real_remove;
1768         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_abstract_multi_map_values_real_clear;
1769         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_abstract_multi_map_values_real_get_size;
1770         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_abstract_multi_map_values_real_get_read_only;
1771         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_map_values_get_property;
1772         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_map_values_set_property;
1773         G_OBJECT_CLASS (klass)->finalize = gee_abstract_multi_map_values_finalize;
1774         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1775         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1776         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1777         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1778         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1779         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1780         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1781         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUES_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));
1782 }
1783
1784
1785 static void gee_abstract_multi_map_values_instance_init (GeeAbstractMultiMapValues * self) {
1786         self->priv = GEE_ABSTRACT_MULTI_MAP_VALUES_GET_PRIVATE (self);
1787 }
1788
1789
1790 static void gee_abstract_multi_map_values_finalize (GObject* obj) {
1791         GeeAbstractMultiMapValues * self;
1792         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, GeeAbstractMultiMapValues);
1793         _g_object_unref0 (self->_multi_map);
1794         G_OBJECT_CLASS (gee_abstract_multi_map_values_parent_class)->finalize (obj);
1795 }
1796
1797
1798 static GType gee_abstract_multi_map_values_get_type (void) {
1799         static volatile gsize gee_abstract_multi_map_values_type_id__volatile = 0;
1800         if (g_once_init_enter (&gee_abstract_multi_map_values_type_id__volatile)) {
1801                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiMapValuesClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_map_values_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiMapValues), 0, (GInstanceInitFunc) gee_abstract_multi_map_values_instance_init, NULL };
1802                 GType gee_abstract_multi_map_values_type_id;
1803                 gee_abstract_multi_map_values_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_COLLECTION, "GeeAbstractMultiMapValues", &g_define_type_info, 0);
1804                 g_once_init_leave (&gee_abstract_multi_map_values_type_id__volatile, gee_abstract_multi_map_values_type_id);
1805         }
1806         return gee_abstract_multi_map_values_type_id__volatile;
1807 }
1808
1809
1810 static void _vala_gee_abstract_multi_map_values_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1811         GeeAbstractMultiMapValues * self;
1812         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, GeeAbstractMultiMapValues);
1813         switch (property_id) {
1814                 case GEE_ABSTRACT_MULTI_MAP_VALUES_SIZE:
1815                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
1816                 break;
1817                 case GEE_ABSTRACT_MULTI_MAP_VALUES_READ_ONLY:
1818                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
1819                 break;
1820                 default:
1821                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1822                 break;
1823         }
1824 }
1825
1826
1827 static void _vala_gee_abstract_multi_map_values_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1828         GeeAbstractMultiMapValues * self;
1829         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_VALUES, GeeAbstractMultiMapValues);
1830         switch (property_id) {
1831                 case GEE_ABSTRACT_MULTI_MAP_VALUES_K_TYPE:
1832                 self->priv->k_type = g_value_get_gtype (value);
1833                 break;
1834                 case GEE_ABSTRACT_MULTI_MAP_VALUES_K_DUP_FUNC:
1835                 self->priv->k_dup_func = g_value_get_pointer (value);
1836                 break;
1837                 case GEE_ABSTRACT_MULTI_MAP_VALUES_K_DESTROY_FUNC:
1838                 self->priv->k_destroy_func = g_value_get_pointer (value);
1839                 break;
1840                 case GEE_ABSTRACT_MULTI_MAP_VALUES_V_TYPE:
1841                 self->priv->v_type = g_value_get_gtype (value);
1842                 break;
1843                 case GEE_ABSTRACT_MULTI_MAP_VALUES_V_DUP_FUNC:
1844                 self->priv->v_dup_func = g_value_get_pointer (value);
1845                 break;
1846                 case GEE_ABSTRACT_MULTI_MAP_VALUES_V_DESTROY_FUNC:
1847                 self->priv->v_destroy_func = g_value_get_pointer (value);
1848                 break;
1849                 default:
1850                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1851                 break;
1852         }
1853 }
1854
1855
1856 static GeeAbstractMultiMapMappingIterator* gee_abstract_multi_map_mapping_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
1857         GeeAbstractMultiMapMappingIterator * self = NULL;
1858         GeeMapIterator* _tmp0_;
1859         GeeMapIterator* _tmp1_;
1860         self = (GeeAbstractMultiMapMappingIterator*) g_object_new (object_type, NULL);
1861         self->priv->k_type = k_type;
1862         self->priv->k_dup_func = k_dup_func;
1863         self->priv->k_destroy_func = k_destroy_func;
1864         self->priv->v_type = v_type;
1865         self->priv->v_dup_func = v_dup_func;
1866         self->priv->v_destroy_func = v_destroy_func;
1867         _tmp0_ = outer;
1868         _tmp1_ = _g_object_ref0 (_tmp0_);
1869         _g_object_unref0 (self->outer);
1870         self->outer = _tmp1_;
1871         return self;
1872 }
1873
1874
1875 static GeeAbstractMultiMapMappingIterator* gee_abstract_multi_map_mapping_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
1876         return gee_abstract_multi_map_mapping_iterator_construct (GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, outer);
1877 }
1878
1879
1880 static gboolean gee_abstract_multi_map_mapping_iterator_next (GeeAbstractMultiMapMappingIterator* self) {
1881         gboolean result = FALSE;
1882         gboolean _tmp0_ = FALSE;
1883         GeeIterator* _tmp1_;
1884         gboolean _tmp4_;
1885         g_return_val_if_fail (self != NULL, FALSE);
1886         _tmp1_ = self->inner;
1887         if (_tmp1_ != NULL) {
1888                 GeeIterator* _tmp2_;
1889                 gboolean _tmp3_ = FALSE;
1890                 _tmp2_ = self->inner;
1891                 _tmp3_ = gee_iterator_next (_tmp2_);
1892                 _tmp0_ = _tmp3_;
1893         } else {
1894                 _tmp0_ = FALSE;
1895         }
1896         _tmp4_ = _tmp0_;
1897         if (_tmp4_) {
1898                 result = TRUE;
1899                 return result;
1900         } else {
1901                 GeeMapIterator* _tmp5_;
1902                 gboolean _tmp6_ = FALSE;
1903                 _tmp5_ = self->outer;
1904                 _tmp6_ = gee_map_iterator_next (_tmp5_);
1905                 if (_tmp6_) {
1906                         GeeMapIterator* _tmp7_;
1907                         gpointer _tmp8_ = NULL;
1908                         GeeCollection* _tmp9_;
1909                         GeeIterator* _tmp10_ = NULL;
1910                         GeeIterator* _tmp11_;
1911                         gboolean _tmp12_ = FALSE;
1912                         _tmp7_ = self->outer;
1913                         _tmp8_ = gee_map_iterator_get_value (_tmp7_);
1914                         _tmp9_ = (GeeCollection*) _tmp8_;
1915                         _tmp10_ = gee_iterable_iterator ((GeeIterable*) _tmp9_);
1916                         _g_object_unref0 (self->inner);
1917                         self->inner = _tmp10_;
1918                         _g_object_unref0 (_tmp9_);
1919                         _tmp11_ = self->inner;
1920                         _tmp12_ = gee_iterator_next (_tmp11_);
1921                         _vala_assert (_tmp12_, "inner.next ()");
1922                         result = TRUE;
1923                         return result;
1924                 } else {
1925                         result = FALSE;
1926                         return result;
1927                 }
1928         }
1929 }
1930
1931
1932 static gboolean gee_abstract_multi_map_mapping_iterator_has_next (GeeAbstractMultiMapMappingIterator* self) {
1933         gboolean result = FALSE;
1934         gboolean _tmp0_ = FALSE;
1935         GeeIterator* _tmp1_;
1936         gboolean _tmp2_ = FALSE;
1937         gboolean _tmp5_;
1938         g_return_val_if_fail (self != NULL, FALSE);
1939         _tmp1_ = self->inner;
1940         _tmp2_ = gee_iterator_has_next (_tmp1_);
1941         if (_tmp2_) {
1942                 _tmp0_ = TRUE;
1943         } else {
1944                 GeeMapIterator* _tmp3_;
1945                 gboolean _tmp4_ = FALSE;
1946                 _tmp3_ = self->outer;
1947                 _tmp4_ = gee_map_iterator_has_next (_tmp3_);
1948                 _tmp0_ = _tmp4_;
1949         }
1950         _tmp5_ = _tmp0_;
1951         result = _tmp5_;
1952         return result;
1953 }
1954
1955
1956 static void gee_abstract_multi_map_mapping_iterator_remove (GeeAbstractMultiMapMappingIterator* self) {
1957         g_return_if_fail (self != NULL);
1958         g_assert_not_reached ();
1959 }
1960
1961
1962 static void gee_abstract_multi_map_mapping_iterator_unset (GeeAbstractMultiMapMappingIterator* self) {
1963         GeeIterator* _tmp0_;
1964         GeeMapIterator* _tmp1_;
1965         gpointer _tmp2_ = NULL;
1966         GeeCollection* _tmp3_;
1967         gboolean _tmp4_;
1968         gboolean _tmp5_;
1969         gboolean _tmp6_;
1970         g_return_if_fail (self != NULL);
1971         _tmp0_ = self->inner;
1972         gee_iterator_remove (_tmp0_);
1973         _tmp1_ = self->outer;
1974         _tmp2_ = gee_map_iterator_get_value (_tmp1_);
1975         _tmp3_ = (GeeCollection*) _tmp2_;
1976         _tmp4_ = gee_collection_get_is_empty (_tmp3_);
1977         _tmp5_ = _tmp4_;
1978         _tmp6_ = _tmp5_;
1979         _g_object_unref0 (_tmp3_);
1980         if (_tmp6_) {
1981                 GeeMapIterator* _tmp7_;
1982                 _tmp7_ = self->outer;
1983                 gee_map_iterator_unset (_tmp7_);
1984         }
1985 }
1986
1987
1988 static gboolean gee_abstract_multi_map_mapping_iterator_get_read_only (GeeAbstractMultiMapMappingIterator* self) {
1989         g_return_val_if_fail (self != NULL, FALSE);
1990         return GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_GET_CLASS (self)->get_read_only (self);
1991 }
1992
1993
1994 static gboolean gee_abstract_multi_map_mapping_iterator_real_get_read_only (GeeAbstractMultiMapMappingIterator* base) {
1995         gboolean result;
1996         GeeAbstractMultiMapMappingIterator* self;
1997         self = base;
1998         result = TRUE;
1999         return result;
2000 }
2001
2002
2003 static gboolean gee_abstract_multi_map_mapping_iterator_get_valid (GeeAbstractMultiMapMappingIterator* self) {
2004         gboolean result;
2005         gboolean _tmp0_ = FALSE;
2006         GeeIterator* _tmp1_;
2007         gboolean _tmp5_;
2008         g_return_val_if_fail (self != NULL, FALSE);
2009         _tmp1_ = self->inner;
2010         if (_tmp1_ != NULL) {
2011                 GeeIterator* _tmp2_;
2012                 gboolean _tmp3_;
2013                 gboolean _tmp4_;
2014                 _tmp2_ = self->inner;
2015                 _tmp3_ = gee_iterator_get_valid (_tmp2_);
2016                 _tmp4_ = _tmp3_;
2017                 _tmp0_ = _tmp4_;
2018         } else {
2019                 _tmp0_ = FALSE;
2020         }
2021         _tmp5_ = _tmp0_;
2022         result = _tmp5_;
2023         return result;
2024 }
2025
2026
2027 static void gee_abstract_multi_map_mapping_iterator_class_init (GeeAbstractMultiMapMappingIteratorClass * klass) {
2028         gee_abstract_multi_map_mapping_iterator_parent_class = g_type_class_peek_parent (klass);
2029         g_type_class_add_private (klass, sizeof (GeeAbstractMultiMapMappingIteratorPrivate));
2030         GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_CLASS (klass)->get_read_only = gee_abstract_multi_map_mapping_iterator_real_get_read_only;
2031         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_map_mapping_iterator_get_property;
2032         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_map_mapping_iterator_set_property;
2033         G_OBJECT_CLASS (klass)->finalize = gee_abstract_multi_map_mapping_iterator_finalize;
2034         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_TYPE, g_param_spec_gtype ("k-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2035         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2036         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2037         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_TYPE, g_param_spec_gtype ("v-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2038         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2039         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2040         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_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));
2041         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAPPING_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));
2042 }
2043
2044
2045 static void gee_abstract_multi_map_mapping_iterator_instance_init (GeeAbstractMultiMapMappingIterator * self) {
2046         self->priv = GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_GET_PRIVATE (self);
2047         self->inner = NULL;
2048 }
2049
2050
2051 static void gee_abstract_multi_map_mapping_iterator_finalize (GObject* obj) {
2052         GeeAbstractMultiMapMappingIterator * self;
2053         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, GeeAbstractMultiMapMappingIterator);
2054         _g_object_unref0 (self->outer);
2055         _g_object_unref0 (self->inner);
2056         G_OBJECT_CLASS (gee_abstract_multi_map_mapping_iterator_parent_class)->finalize (obj);
2057 }
2058
2059
2060 static GType gee_abstract_multi_map_mapping_iterator_get_type (void) {
2061         static volatile gsize gee_abstract_multi_map_mapping_iterator_type_id__volatile = 0;
2062         if (g_once_init_enter (&gee_abstract_multi_map_mapping_iterator_type_id__volatile)) {
2063                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiMapMappingIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_map_mapping_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiMapMappingIterator), 0, (GInstanceInitFunc) gee_abstract_multi_map_mapping_iterator_instance_init, NULL };
2064                 GType gee_abstract_multi_map_mapping_iterator_type_id;
2065                 gee_abstract_multi_map_mapping_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeAbstractMultiMapMappingIterator", &g_define_type_info, 0);
2066                 g_once_init_leave (&gee_abstract_multi_map_mapping_iterator_type_id__volatile, gee_abstract_multi_map_mapping_iterator_type_id);
2067         }
2068         return gee_abstract_multi_map_mapping_iterator_type_id__volatile;
2069 }
2070
2071
2072 static void _vala_gee_abstract_multi_map_mapping_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2073         GeeAbstractMultiMapMappingIterator * self;
2074         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, GeeAbstractMultiMapMappingIterator);
2075         switch (property_id) {
2076                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_READ_ONLY:
2077                 g_value_set_boolean (value, gee_abstract_multi_map_mapping_iterator_get_read_only (self));
2078                 break;
2079                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_VALID:
2080                 g_value_set_boolean (value, gee_abstract_multi_map_mapping_iterator_get_valid (self));
2081                 break;
2082                 default:
2083                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2084                 break;
2085         }
2086 }
2087
2088
2089 static void _vala_gee_abstract_multi_map_mapping_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2090         GeeAbstractMultiMapMappingIterator * self;
2091         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, GeeAbstractMultiMapMappingIterator);
2092         switch (property_id) {
2093                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_TYPE:
2094                 self->priv->k_type = g_value_get_gtype (value);
2095                 break;
2096                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_DUP_FUNC:
2097                 self->priv->k_dup_func = g_value_get_pointer (value);
2098                 break;
2099                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_K_DESTROY_FUNC:
2100                 self->priv->k_destroy_func = g_value_get_pointer (value);
2101                 break;
2102                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_TYPE:
2103                 self->priv->v_type = g_value_get_gtype (value);
2104                 break;
2105                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_DUP_FUNC:
2106                 self->priv->v_dup_func = g_value_get_pointer (value);
2107                 break;
2108                 case GEE_ABSTRACT_MULTI_MAP_MAPPING_ITERATOR_V_DESTROY_FUNC:
2109                 self->priv->v_destroy_func = g_value_get_pointer (value);
2110                 break;
2111                 default:
2112                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2113                 break;
2114         }
2115 }
2116
2117
2118 static GeeAbstractMultiMapKeyIterator* gee_abstract_multi_map_key_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
2119         GeeAbstractMultiMapKeyIterator * self = NULL;
2120         GeeMapIterator* _tmp0_;
2121         _tmp0_ = outer;
2122         self = (GeeAbstractMultiMapKeyIterator*) gee_abstract_multi_map_mapping_iterator_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp0_);
2123         self->priv->k_type = k_type;
2124         self->priv->k_dup_func = k_dup_func;
2125         self->priv->k_destroy_func = k_destroy_func;
2126         self->priv->v_type = v_type;
2127         self->priv->v_dup_func = v_dup_func;
2128         self->priv->v_destroy_func = v_destroy_func;
2129         return self;
2130 }
2131
2132
2133 static GeeAbstractMultiMapKeyIterator* gee_abstract_multi_map_key_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
2134         return gee_abstract_multi_map_key_iterator_construct (GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, outer);
2135 }
2136
2137
2138 static gpointer gee_abstract_multi_map_key_iterator_real_get (GeeIterator* base) {
2139         GeeAbstractMultiMapKeyIterator * self;
2140         gpointer result = NULL;
2141         gboolean _tmp0_;
2142         gboolean _tmp1_;
2143         GeeMapIterator* _tmp2_;
2144         gpointer _tmp3_ = NULL;
2145         self = (GeeAbstractMultiMapKeyIterator*) base;
2146         _tmp0_ = gee_iterator_get_valid ((GeeIterator*) self);
2147         _tmp1_ = _tmp0_;
2148         _vala_assert (_tmp1_, "valid");
2149         _tmp2_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2150         _tmp3_ = gee_map_iterator_get_key (_tmp2_);
2151         result = _tmp3_;
2152         return result;
2153 }
2154
2155
2156 static Block1Data* block1_data_ref (Block1Data* _data1_) {
2157         g_atomic_int_inc (&_data1_->_ref_count_);
2158         return _data1_;
2159 }
2160
2161
2162 static void block1_data_unref (void * _userdata_) {
2163         Block1Data* _data1_;
2164         _data1_ = (Block1Data*) _userdata_;
2165         if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
2166                 GeeAbstractMultiMapKeyIterator * self;
2167                 self = _data1_->self;
2168                 _g_object_unref0 (self);
2169                 g_slice_free (Block1Data, _data1_);
2170         }
2171 }
2172
2173
2174 static Block2Data* block2_data_ref (Block2Data* _data2_) {
2175         g_atomic_int_inc (&_data2_->_ref_count_);
2176         return _data2_;
2177 }
2178
2179
2180 static void block2_data_unref (void * _userdata_) {
2181         Block2Data* _data2_;
2182         _data2_ = (Block2Data*) _userdata_;
2183         if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
2184                 GeeAbstractMultiMapKeyIterator * self;
2185                 self = _data2_->_data1_->self;
2186                 ((_data2_->key == NULL) || (self->priv->k_destroy_func == NULL)) ? NULL : (_data2_->key = (self->priv->k_destroy_func (_data2_->key), NULL));
2187                 block1_data_unref (_data2_->_data1_);
2188                 _data2_->_data1_ = NULL;
2189                 g_slice_free (Block2Data, _data2_);
2190         }
2191 }
2192
2193
2194 static gboolean ___lambda29_ (Block2Data* _data2_, gpointer v) {
2195         Block1Data* _data1_;
2196         GeeAbstractMultiMapKeyIterator * self;
2197         gboolean result = FALSE;
2198         GeeForallFunc _tmp0_;
2199         void* _tmp0__target;
2200         gconstpointer _tmp1_;
2201         gpointer _tmp2_;
2202         gboolean _tmp3_ = FALSE;
2203         _data1_ = _data2_->_data1_;
2204         self = _data1_->self;
2205         _tmp0_ = _data1_->f;
2206         _tmp0__target = _data1_->f_target;
2207         _tmp1_ = _data2_->key;
2208         _tmp2_ = ((_tmp1_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp1_) : ((gpointer) _tmp1_);
2209         _tmp3_ = _tmp0_ (_tmp2_, _tmp0__target);
2210         result = _tmp3_;
2211         ((v == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (v = (self->priv->v_destroy_func (v), NULL));
2212         return result;
2213 }
2214
2215
2216 static gboolean ____lambda29__gee_forall_func (gpointer g, gpointer self) {
2217         gboolean result;
2218         result = ___lambda29_ (self, g);
2219         return result;
2220 }
2221
2222
2223 static Block3Data* block3_data_ref (Block3Data* _data3_) {
2224         g_atomic_int_inc (&_data3_->_ref_count_);
2225         return _data3_;
2226 }
2227
2228
2229 static void block3_data_unref (void * _userdata_) {
2230         Block3Data* _data3_;
2231         _data3_ = (Block3Data*) _userdata_;
2232         if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
2233                 GeeAbstractMultiMapKeyIterator * self;
2234                 self = _data3_->_data1_->self;
2235                 ((_data3_->key == NULL) || (self->priv->k_destroy_func == NULL)) ? NULL : (_data3_->key = (self->priv->k_destroy_func (_data3_->key), NULL));
2236                 block1_data_unref (_data3_->_data1_);
2237                 _data3_->_data1_ = NULL;
2238                 g_slice_free (Block3Data, _data3_);
2239         }
2240 }
2241
2242
2243 static gboolean __lambda31_ (Block3Data* _data3_, gpointer v) {
2244         Block1Data* _data1_;
2245         GeeAbstractMultiMapKeyIterator * self;
2246         gboolean result = FALSE;
2247         GeeForallFunc _tmp0_;
2248         void* _tmp0__target;
2249         gconstpointer _tmp1_;
2250         gpointer _tmp2_;
2251         gboolean _tmp3_ = FALSE;
2252         _data1_ = _data3_->_data1_;
2253         self = _data1_->self;
2254         _tmp0_ = _data1_->f;
2255         _tmp0__target = _data1_->f_target;
2256         _tmp1_ = _data3_->key;
2257         _tmp2_ = ((_tmp1_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp1_) : ((gpointer) _tmp1_);
2258         _tmp3_ = _tmp0_ (_tmp2_, _tmp0__target);
2259         result = _tmp3_;
2260         ((v == NULL) || (self->priv->v_destroy_func == NULL)) ? NULL : (v = (self->priv->v_destroy_func (v), NULL));
2261         return result;
2262 }
2263
2264
2265 static gboolean ___lambda31__gee_forall_func (gpointer g, gpointer self) {
2266         gboolean result;
2267         result = __lambda31_ (self, g);
2268         return result;
2269 }
2270
2271
2272 static gboolean __lambda30_ (Block1Data* _data1_, gconstpointer key, GeeCollection* col) {
2273         GeeAbstractMultiMapKeyIterator * self;
2274         gboolean result = FALSE;
2275         Block3Data* _data3_;
2276         gconstpointer _tmp0_;
2277         gpointer _tmp1_;
2278         GeeCollection* _tmp2_;
2279         gboolean _tmp3_ = FALSE;
2280         self = _data1_->self;
2281         g_return_val_if_fail (col != NULL, FALSE);
2282         _data3_ = g_slice_new0 (Block3Data);
2283         _data3_->_ref_count_ = 1;
2284         _data3_->_data1_ = block1_data_ref (_data1_);
2285         _tmp0_ = key;
2286         _tmp1_ = ((_tmp0_ != NULL) && (self->priv->k_dup_func != NULL)) ? self->priv->k_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
2287         ((_data3_->key == NULL) || (self->priv->k_destroy_func == NULL)) ? NULL : (_data3_->key = (self->priv->k_destroy_func (_data3_->key), NULL));
2288         _data3_->key = _tmp1_;
2289         _tmp2_ = col;
2290         _tmp3_ = gee_traversable_foreach ((GeeTraversable*) _tmp2_, ___lambda31__gee_forall_func, _data3_);
2291         result = _tmp3_;
2292         block3_data_unref (_data3_);
2293         _data3_ = NULL;
2294         return result;
2295 }
2296
2297
2298 static gboolean ___lambda30__gee_forall_map_func (gconstpointer k, gconstpointer v, gpointer self) {
2299         gboolean result;
2300         result = __lambda30_ (self, k, v);
2301         return result;
2302 }
2303
2304
2305 static gboolean gee_abstract_multi_map_key_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
2306         GeeAbstractMultiMapKeyIterator * self;
2307         gboolean result = FALSE;
2308         Block1Data* _data1_;
2309         GeeForallFunc _tmp0_;
2310         void* _tmp0__target;
2311         gboolean _tmp1_ = FALSE;
2312         GeeIterator* _tmp2_;
2313         gboolean _tmp6_;
2314         GeeMapIterator* _tmp12_;
2315         gboolean _tmp13_ = FALSE;
2316         self = (GeeAbstractMultiMapKeyIterator*) base;
2317         _data1_ = g_slice_new0 (Block1Data);
2318         _data1_->_ref_count_ = 1;
2319         _data1_->self = g_object_ref (self);
2320         _tmp0_ = f;
2321         _tmp0__target = f_target;
2322         _data1_->f = _tmp0_;
2323         _data1_->f_target = _tmp0__target;
2324         _tmp2_ = ((GeeAbstractMultiMapMappingIterator*) self)->inner;
2325         if (_tmp2_ != NULL) {
2326                 GeeMapIterator* _tmp3_;
2327                 gboolean _tmp4_;
2328                 gboolean _tmp5_;
2329                 _tmp3_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2330                 _tmp4_ = gee_map_iterator_get_valid (_tmp3_);
2331                 _tmp5_ = _tmp4_;
2332                 _tmp1_ = _tmp5_;
2333         } else {
2334                 _tmp1_ = FALSE;
2335         }
2336         _tmp6_ = _tmp1_;
2337         if (_tmp6_) {
2338                 Block2Data* _data2_;
2339                 GeeMapIterator* _tmp7_;
2340                 gpointer _tmp8_ = NULL;
2341                 GeeIterator* _tmp9_;
2342                 gboolean _tmp10_ = FALSE;
2343                 GeeMapIterator* _tmp11_;
2344                 _data2_ = g_slice_new0 (Block2Data);
2345                 _data2_->_ref_count_ = 1;
2346                 _data2_->_data1_ = block1_data_ref (_data1_);
2347                 _tmp7_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2348                 _tmp8_ = gee_map_iterator_get_key (_tmp7_);
2349                 _data2_->key = _tmp8_;
2350                 _tmp9_ = ((GeeAbstractMultiMapMappingIterator*) self)->inner;
2351                 _tmp10_ = gee_traversable_foreach ((GeeTraversable*) _tmp9_, ____lambda29__gee_forall_func, _data2_);
2352                 if (!_tmp10_) {
2353                         result = FALSE;
2354                         block2_data_unref (_data2_);
2355                         _data2_ = NULL;
2356                         block1_data_unref (_data1_);
2357                         _data1_ = NULL;
2358                         return result;
2359                 }
2360                 _tmp11_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2361                 gee_map_iterator_next (_tmp11_);
2362                 block2_data_unref (_data2_);
2363                 _data2_ = NULL;
2364         }
2365         _tmp12_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2366         _tmp13_ = gee_map_iterator_foreach (_tmp12_, ___lambda30__gee_forall_map_func, _data1_);
2367         result = _tmp13_;
2368         block1_data_unref (_data1_);
2369         _data1_ = NULL;
2370         return result;
2371 }
2372
2373
2374 static void gee_abstract_multi_map_key_iterator_class_init (GeeAbstractMultiMapKeyIteratorClass * klass) {
2375         gee_abstract_multi_map_key_iterator_parent_class = g_type_class_peek_parent (klass);
2376         g_type_class_add_private (klass, sizeof (GeeAbstractMultiMapKeyIteratorPrivate));
2377         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_map_key_iterator_get_property;
2378         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_map_key_iterator_set_property;
2379         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_TYPE, g_param_spec_gtype ("k-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2380         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2381         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2382         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_TYPE, g_param_spec_gtype ("v-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2383         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2384         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2385 }
2386
2387
2388 static GType gee_abstract_multi_map_key_iterator_gee_traversable_get_g_type (GeeAbstractMultiMapKeyIterator* self) {
2389         return self->priv->k_type;
2390 }
2391
2392
2393 static GBoxedCopyFunc gee_abstract_multi_map_key_iterator_gee_traversable_get_g_dup_func (GeeAbstractMultiMapKeyIterator* self) {
2394         return self->priv->k_dup_func;
2395 }
2396
2397
2398 static GDestroyNotify gee_abstract_multi_map_key_iterator_gee_traversable_get_g_destroy_func (GeeAbstractMultiMapKeyIterator* self) {
2399         return self->priv->k_destroy_func;
2400 }
2401
2402
2403 static void gee_abstract_multi_map_key_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
2404         gee_abstract_multi_map_key_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
2405         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_abstract_multi_map_key_iterator_real_foreach;
2406         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_abstract_multi_map_key_iterator_gee_traversable_get_g_type;
2407         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_abstract_multi_map_key_iterator_gee_traversable_get_g_dup_func;
2408         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_abstract_multi_map_key_iterator_gee_traversable_get_g_destroy_func;
2409 }
2410
2411
2412 static void gee_abstract_multi_map_key_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
2413         gee_abstract_multi_map_key_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
2414         iface->get = (gpointer (*)(GeeIterator*)) gee_abstract_multi_map_key_iterator_real_get;
2415         iface->next = (gboolean (*)(GeeIterator*)) gee_abstract_multi_map_mapping_iterator_next;
2416         iface->has_next = (gboolean (*)(GeeIterator*)) gee_abstract_multi_map_mapping_iterator_has_next;
2417         iface->remove = (void (*)(GeeIterator*)) gee_abstract_multi_map_mapping_iterator_remove;
2418         iface->get_valid = (gboolean (*) (GeeIterator *)) gee_abstract_multi_map_mapping_iterator_get_valid;
2419         iface->get_read_only = (gboolean (*) (GeeIterator *)) gee_abstract_multi_map_mapping_iterator_get_read_only;
2420 }
2421
2422
2423 static void gee_abstract_multi_map_key_iterator_instance_init (GeeAbstractMultiMapKeyIterator * self) {
2424         self->priv = GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_GET_PRIVATE (self);
2425 }
2426
2427
2428 static GType gee_abstract_multi_map_key_iterator_get_type (void) {
2429         static volatile gsize gee_abstract_multi_map_key_iterator_type_id__volatile = 0;
2430         if (g_once_init_enter (&gee_abstract_multi_map_key_iterator_type_id__volatile)) {
2431                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiMapKeyIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_map_key_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiMapKeyIterator), 0, (GInstanceInitFunc) gee_abstract_multi_map_key_iterator_instance_init, NULL };
2432                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_abstract_multi_map_key_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2433                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_abstract_multi_map_key_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2434                 GType gee_abstract_multi_map_key_iterator_type_id;
2435                 gee_abstract_multi_map_key_iterator_type_id = g_type_register_static (GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, "GeeAbstractMultiMapKeyIterator", &g_define_type_info, 0);
2436                 g_type_add_interface_static (gee_abstract_multi_map_key_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
2437                 g_type_add_interface_static (gee_abstract_multi_map_key_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
2438                 g_once_init_leave (&gee_abstract_multi_map_key_iterator_type_id__volatile, gee_abstract_multi_map_key_iterator_type_id);
2439         }
2440         return gee_abstract_multi_map_key_iterator_type_id__volatile;
2441 }
2442
2443
2444 static void _vala_gee_abstract_multi_map_key_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2445         GeeAbstractMultiMapKeyIterator * self;
2446         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR, GeeAbstractMultiMapKeyIterator);
2447         switch (property_id) {
2448                 default:
2449                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2450                 break;
2451         }
2452 }
2453
2454
2455 static void _vala_gee_abstract_multi_map_key_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2456         GeeAbstractMultiMapKeyIterator * self;
2457         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_KEY_ITERATOR, GeeAbstractMultiMapKeyIterator);
2458         switch (property_id) {
2459                 case GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_TYPE:
2460                 self->priv->k_type = g_value_get_gtype (value);
2461                 break;
2462                 case GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_DUP_FUNC:
2463                 self->priv->k_dup_func = g_value_get_pointer (value);
2464                 break;
2465                 case GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_K_DESTROY_FUNC:
2466                 self->priv->k_destroy_func = g_value_get_pointer (value);
2467                 break;
2468                 case GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_TYPE:
2469                 self->priv->v_type = g_value_get_gtype (value);
2470                 break;
2471                 case GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_DUP_FUNC:
2472                 self->priv->v_dup_func = g_value_get_pointer (value);
2473                 break;
2474                 case GEE_ABSTRACT_MULTI_MAP_KEY_ITERATOR_V_DESTROY_FUNC:
2475                 self->priv->v_destroy_func = g_value_get_pointer (value);
2476                 break;
2477                 default:
2478                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2479                 break;
2480         }
2481 }
2482
2483
2484 static GeeAbstractMultiMapValueIterator* gee_abstract_multi_map_value_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
2485         GeeAbstractMultiMapValueIterator * self = NULL;
2486         GeeMapIterator* _tmp0_;
2487         _tmp0_ = outer;
2488         self = (GeeAbstractMultiMapValueIterator*) gee_abstract_multi_map_mapping_iterator_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp0_);
2489         self->priv->k_type = k_type;
2490         self->priv->k_dup_func = k_dup_func;
2491         self->priv->k_destroy_func = k_destroy_func;
2492         self->priv->v_type = v_type;
2493         self->priv->v_dup_func = v_dup_func;
2494         self->priv->v_destroy_func = v_destroy_func;
2495         return self;
2496 }
2497
2498
2499 static GeeAbstractMultiMapValueIterator* gee_abstract_multi_map_value_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
2500         return gee_abstract_multi_map_value_iterator_construct (GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, outer);
2501 }
2502
2503
2504 static gpointer gee_abstract_multi_map_value_iterator_real_get (GeeIterator* base) {
2505         GeeAbstractMultiMapValueIterator * self;
2506         gpointer result = NULL;
2507         gboolean _tmp0_;
2508         gboolean _tmp1_;
2509         GeeIterator* _tmp2_;
2510         gpointer _tmp3_ = NULL;
2511         self = (GeeAbstractMultiMapValueIterator*) base;
2512         _tmp0_ = gee_iterator_get_valid ((GeeIterator*) self);
2513         _tmp1_ = _tmp0_;
2514         _vala_assert (_tmp1_, "valid");
2515         _tmp2_ = ((GeeAbstractMultiMapMappingIterator*) self)->inner;
2516         _tmp3_ = gee_iterator_get (_tmp2_);
2517         result = _tmp3_;
2518         return result;
2519 }
2520
2521
2522 static Block4Data* block4_data_ref (Block4Data* _data4_) {
2523         g_atomic_int_inc (&_data4_->_ref_count_);
2524         return _data4_;
2525 }
2526
2527
2528 static void block4_data_unref (void * _userdata_) {
2529         Block4Data* _data4_;
2530         _data4_ = (Block4Data*) _userdata_;
2531         if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
2532                 GeeAbstractMultiMapValueIterator * self;
2533                 self = _data4_->self;
2534                 _g_object_unref0 (self);
2535                 g_slice_free (Block4Data, _data4_);
2536         }
2537 }
2538
2539
2540 static gboolean __lambda32_ (Block4Data* _data4_, gconstpointer key, GeeCollection* col) {
2541         GeeAbstractMultiMapValueIterator * self;
2542         gboolean result = FALSE;
2543         GeeCollection* _tmp0_;
2544         GeeForallFunc _tmp1_;
2545         void* _tmp1__target;
2546         gboolean _tmp2_ = FALSE;
2547         self = _data4_->self;
2548         g_return_val_if_fail (col != NULL, FALSE);
2549         _tmp0_ = col;
2550         _tmp1_ = _data4_->f;
2551         _tmp1__target = _data4_->f_target;
2552         _tmp2_ = gee_traversable_foreach ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target);
2553         result = _tmp2_;
2554         return result;
2555 }
2556
2557
2558 static gboolean ___lambda32__gee_forall_map_func (gconstpointer k, gconstpointer v, gpointer self) {
2559         gboolean result;
2560         result = __lambda32_ (self, k, v);
2561         return result;
2562 }
2563
2564
2565 static gboolean gee_abstract_multi_map_value_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
2566         GeeAbstractMultiMapValueIterator * self;
2567         gboolean result = FALSE;
2568         Block4Data* _data4_;
2569         GeeForallFunc _tmp0_;
2570         void* _tmp0__target;
2571         gboolean _tmp1_ = FALSE;
2572         GeeIterator* _tmp2_;
2573         gboolean _tmp6_;
2574         GeeMapIterator* _tmp11_;
2575         gboolean _tmp12_ = FALSE;
2576         self = (GeeAbstractMultiMapValueIterator*) base;
2577         _data4_ = g_slice_new0 (Block4Data);
2578         _data4_->_ref_count_ = 1;
2579         _data4_->self = g_object_ref (self);
2580         _tmp0_ = f;
2581         _tmp0__target = f_target;
2582         _data4_->f = _tmp0_;
2583         _data4_->f_target = _tmp0__target;
2584         _tmp2_ = ((GeeAbstractMultiMapMappingIterator*) self)->inner;
2585         if (_tmp2_ != NULL) {
2586                 GeeMapIterator* _tmp3_;
2587                 gboolean _tmp4_;
2588                 gboolean _tmp5_;
2589                 _tmp3_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2590                 _tmp4_ = gee_map_iterator_get_valid (_tmp3_);
2591                 _tmp5_ = _tmp4_;
2592                 _tmp1_ = _tmp5_;
2593         } else {
2594                 _tmp1_ = FALSE;
2595         }
2596         _tmp6_ = _tmp1_;
2597         if (_tmp6_) {
2598                 GeeIterator* _tmp7_;
2599                 GeeForallFunc _tmp8_;
2600                 void* _tmp8__target;
2601                 gboolean _tmp9_ = FALSE;
2602                 GeeMapIterator* _tmp10_;
2603                 _tmp7_ = ((GeeAbstractMultiMapMappingIterator*) self)->inner;
2604                 _tmp8_ = _data4_->f;
2605                 _tmp8__target = _data4_->f_target;
2606                 _tmp9_ = gee_traversable_foreach ((GeeTraversable*) _tmp7_, _tmp8_, _tmp8__target);
2607                 if (!_tmp9_) {
2608                         result = FALSE;
2609                         block4_data_unref (_data4_);
2610                         _data4_ = NULL;
2611                         return result;
2612                 }
2613                 _tmp10_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2614                 gee_map_iterator_next (_tmp10_);
2615         }
2616         _tmp11_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2617         _tmp12_ = gee_map_iterator_foreach (_tmp11_, ___lambda32__gee_forall_map_func, _data4_);
2618         result = _tmp12_;
2619         block4_data_unref (_data4_);
2620         _data4_ = NULL;
2621         return result;
2622 }
2623
2624
2625 static void gee_abstract_multi_map_value_iterator_class_init (GeeAbstractMultiMapValueIteratorClass * klass) {
2626         gee_abstract_multi_map_value_iterator_parent_class = g_type_class_peek_parent (klass);
2627         g_type_class_add_private (klass, sizeof (GeeAbstractMultiMapValueIteratorPrivate));
2628         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_map_value_iterator_get_property;
2629         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_map_value_iterator_set_property;
2630         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_TYPE, g_param_spec_gtype ("k-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2631         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2632         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2633         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_TYPE, g_param_spec_gtype ("v-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2634         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2635         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2636 }
2637
2638
2639 static GType gee_abstract_multi_map_value_iterator_gee_traversable_get_g_type (GeeAbstractMultiMapValueIterator* self) {
2640         return self->priv->v_type;
2641 }
2642
2643
2644 static GBoxedCopyFunc gee_abstract_multi_map_value_iterator_gee_traversable_get_g_dup_func (GeeAbstractMultiMapValueIterator* self) {
2645         return self->priv->v_dup_func;
2646 }
2647
2648
2649 static GDestroyNotify gee_abstract_multi_map_value_iterator_gee_traversable_get_g_destroy_func (GeeAbstractMultiMapValueIterator* self) {
2650         return self->priv->v_destroy_func;
2651 }
2652
2653
2654 static void gee_abstract_multi_map_value_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
2655         gee_abstract_multi_map_value_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
2656         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_abstract_multi_map_value_iterator_real_foreach;
2657         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_abstract_multi_map_value_iterator_gee_traversable_get_g_type;
2658         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_abstract_multi_map_value_iterator_gee_traversable_get_g_dup_func;
2659         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_abstract_multi_map_value_iterator_gee_traversable_get_g_destroy_func;
2660 }
2661
2662
2663 static void gee_abstract_multi_map_value_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
2664         gee_abstract_multi_map_value_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
2665         iface->get = (gpointer (*)(GeeIterator*)) gee_abstract_multi_map_value_iterator_real_get;
2666         iface->next = (gboolean (*)(GeeIterator*)) gee_abstract_multi_map_mapping_iterator_next;
2667         iface->has_next = (gboolean (*)(GeeIterator*)) gee_abstract_multi_map_mapping_iterator_has_next;
2668         iface->remove = (void (*)(GeeIterator*)) gee_abstract_multi_map_mapping_iterator_remove;
2669         iface->get_valid = (gboolean (*) (GeeIterator *)) gee_abstract_multi_map_mapping_iterator_get_valid;
2670         iface->get_read_only = (gboolean (*) (GeeIterator *)) gee_abstract_multi_map_mapping_iterator_get_read_only;
2671 }
2672
2673
2674 static void gee_abstract_multi_map_value_iterator_instance_init (GeeAbstractMultiMapValueIterator * self) {
2675         self->priv = GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_GET_PRIVATE (self);
2676 }
2677
2678
2679 static GType gee_abstract_multi_map_value_iterator_get_type (void) {
2680         static volatile gsize gee_abstract_multi_map_value_iterator_type_id__volatile = 0;
2681         if (g_once_init_enter (&gee_abstract_multi_map_value_iterator_type_id__volatile)) {
2682                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiMapValueIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_map_value_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiMapValueIterator), 0, (GInstanceInitFunc) gee_abstract_multi_map_value_iterator_instance_init, NULL };
2683                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_abstract_multi_map_value_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2684                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_abstract_multi_map_value_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2685                 GType gee_abstract_multi_map_value_iterator_type_id;
2686                 gee_abstract_multi_map_value_iterator_type_id = g_type_register_static (GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, "GeeAbstractMultiMapValueIterator", &g_define_type_info, 0);
2687                 g_type_add_interface_static (gee_abstract_multi_map_value_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
2688                 g_type_add_interface_static (gee_abstract_multi_map_value_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
2689                 g_once_init_leave (&gee_abstract_multi_map_value_iterator_type_id__volatile, gee_abstract_multi_map_value_iterator_type_id);
2690         }
2691         return gee_abstract_multi_map_value_iterator_type_id__volatile;
2692 }
2693
2694
2695 static void _vala_gee_abstract_multi_map_value_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2696         GeeAbstractMultiMapValueIterator * self;
2697         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR, GeeAbstractMultiMapValueIterator);
2698         switch (property_id) {
2699                 default:
2700                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2701                 break;
2702         }
2703 }
2704
2705
2706 static void _vala_gee_abstract_multi_map_value_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2707         GeeAbstractMultiMapValueIterator * self;
2708         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_VALUE_ITERATOR, GeeAbstractMultiMapValueIterator);
2709         switch (property_id) {
2710                 case GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_TYPE:
2711                 self->priv->k_type = g_value_get_gtype (value);
2712                 break;
2713                 case GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_DUP_FUNC:
2714                 self->priv->k_dup_func = g_value_get_pointer (value);
2715                 break;
2716                 case GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_K_DESTROY_FUNC:
2717                 self->priv->k_destroy_func = g_value_get_pointer (value);
2718                 break;
2719                 case GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_TYPE:
2720                 self->priv->v_type = g_value_get_gtype (value);
2721                 break;
2722                 case GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_DUP_FUNC:
2723                 self->priv->v_dup_func = g_value_get_pointer (value);
2724                 break;
2725                 case GEE_ABSTRACT_MULTI_MAP_VALUE_ITERATOR_V_DESTROY_FUNC:
2726                 self->priv->v_destroy_func = g_value_get_pointer (value);
2727                 break;
2728                 default:
2729                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2730                 break;
2731         }
2732 }
2733
2734
2735 static GeeAbstractMultiMapMapIterator* gee_abstract_multi_map_map_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
2736         GeeAbstractMultiMapMapIterator * self = NULL;
2737         GeeMapIterator* _tmp0_;
2738         _tmp0_ = outer;
2739         self = (GeeAbstractMultiMapMapIterator*) gee_abstract_multi_map_mapping_iterator_construct (object_type, k_type, (GBoxedCopyFunc) k_dup_func, k_destroy_func, v_type, (GBoxedCopyFunc) v_dup_func, v_destroy_func, _tmp0_);
2740         self->priv->k_type = k_type;
2741         self->priv->k_dup_func = k_dup_func;
2742         self->priv->k_destroy_func = k_destroy_func;
2743         self->priv->v_type = v_type;
2744         self->priv->v_dup_func = v_dup_func;
2745         self->priv->v_destroy_func = v_destroy_func;
2746         return self;
2747 }
2748
2749
2750 static GeeAbstractMultiMapMapIterator* gee_abstract_multi_map_map_iterator_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GeeMapIterator* outer) {
2751         return gee_abstract_multi_map_map_iterator_construct (GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR, k_type, k_dup_func, k_destroy_func, v_type, v_dup_func, v_destroy_func, outer);
2752 }
2753
2754
2755 static gpointer gee_abstract_multi_map_map_iterator_real_get_key (GeeMapIterator* base) {
2756         GeeAbstractMultiMapMapIterator * self;
2757         gpointer result = NULL;
2758         gboolean _tmp0_;
2759         gboolean _tmp1_;
2760         GeeMapIterator* _tmp2_;
2761         gpointer _tmp3_ = NULL;
2762         self = (GeeAbstractMultiMapMapIterator*) base;
2763         _tmp0_ = gee_map_iterator_get_valid ((GeeMapIterator*) self);
2764         _tmp1_ = _tmp0_;
2765         _vala_assert (_tmp1_, "valid");
2766         _tmp2_ = ((GeeAbstractMultiMapMappingIterator*) self)->outer;
2767         _tmp3_ = gee_map_iterator_get_key (_tmp2_);
2768         result = _tmp3_;
2769         return result;
2770 }
2771
2772
2773 static gpointer gee_abstract_multi_map_map_iterator_real_get_value (GeeMapIterator* base) {
2774         GeeAbstractMultiMapMapIterator * self;
2775         gpointer result = NULL;
2776         gboolean _tmp0_;
2777         gboolean _tmp1_;
2778         GeeIterator* _tmp2_;
2779         gpointer _tmp3_ = NULL;
2780         self = (GeeAbstractMultiMapMapIterator*) base;
2781         _tmp0_ = gee_map_iterator_get_valid ((GeeMapIterator*) self);
2782         _tmp1_ = _tmp0_;
2783         _vala_assert (_tmp1_, "valid");
2784         _tmp2_ = ((GeeAbstractMultiMapMappingIterator*) self)->inner;
2785         _tmp3_ = gee_iterator_get (_tmp2_);
2786         result = _tmp3_;
2787         return result;
2788 }
2789
2790
2791 static void gee_abstract_multi_map_map_iterator_real_set_value (GeeMapIterator* base, gconstpointer value) {
2792         GeeAbstractMultiMapMapIterator * self;
2793         self = (GeeAbstractMultiMapMapIterator*) base;
2794         g_assert_not_reached ();
2795 }
2796
2797
2798 static gboolean gee_abstract_multi_map_map_iterator_real_get_mutable (GeeMapIterator* base) {
2799         gboolean result;
2800         GeeAbstractMultiMapMapIterator* self;
2801         self = (GeeAbstractMultiMapMapIterator*) base;
2802         result = FALSE;
2803         return result;
2804 }
2805
2806
2807 static void gee_abstract_multi_map_map_iterator_class_init (GeeAbstractMultiMapMapIteratorClass * klass) {
2808         gee_abstract_multi_map_map_iterator_parent_class = g_type_class_peek_parent (klass);
2809         g_type_class_add_private (klass, sizeof (GeeAbstractMultiMapMapIteratorPrivate));
2810         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_map_map_iterator_get_property;
2811         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_map_map_iterator_set_property;
2812         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_TYPE, g_param_spec_gtype ("k-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2813         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_DUP_FUNC, g_param_spec_pointer ("k-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2814         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_DESTROY_FUNC, g_param_spec_pointer ("k-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2815         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_TYPE, g_param_spec_gtype ("v-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2816         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_DUP_FUNC, g_param_spec_pointer ("v-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2817         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_DESTROY_FUNC, g_param_spec_pointer ("v-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2818         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_MUTABLE, g_param_spec_boolean ("mutable", "mutable", "mutable", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2819 }
2820
2821
2822 static GType gee_abstract_multi_map_map_iterator_gee_map_iterator_get_k_type (GeeAbstractMultiMapMapIterator* self) {
2823         return self->priv->k_type;
2824 }
2825
2826
2827 static GBoxedCopyFunc gee_abstract_multi_map_map_iterator_gee_map_iterator_get_k_dup_func (GeeAbstractMultiMapMapIterator* self) {
2828         return self->priv->k_dup_func;
2829 }
2830
2831
2832 static GDestroyNotify gee_abstract_multi_map_map_iterator_gee_map_iterator_get_k_destroy_func (GeeAbstractMultiMapMapIterator* self) {
2833         return self->priv->k_destroy_func;
2834 }
2835
2836
2837 static GType gee_abstract_multi_map_map_iterator_gee_map_iterator_get_v_type (GeeAbstractMultiMapMapIterator* self) {
2838         return self->priv->v_type;
2839 }
2840
2841
2842 static GBoxedCopyFunc gee_abstract_multi_map_map_iterator_gee_map_iterator_get_v_dup_func (GeeAbstractMultiMapMapIterator* self) {
2843         return self->priv->v_dup_func;
2844 }
2845
2846
2847 static GDestroyNotify gee_abstract_multi_map_map_iterator_gee_map_iterator_get_v_destroy_func (GeeAbstractMultiMapMapIterator* self) {
2848         return self->priv->v_destroy_func;
2849 }
2850
2851
2852 static void gee_abstract_multi_map_map_iterator_gee_map_iterator_interface_init (GeeMapIteratorIface * iface) {
2853         gee_abstract_multi_map_map_iterator_gee_map_iterator_parent_iface = g_type_interface_peek_parent (iface);
2854         iface->get_key = (gpointer (*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_real_get_key;
2855         iface->get_value = (gpointer (*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_real_get_value;
2856         iface->set_value = (void (*)(GeeMapIterator*, gconstpointer)) gee_abstract_multi_map_map_iterator_real_set_value;
2857         iface->get_k_type = (GType(*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_gee_map_iterator_get_k_type;
2858         iface->get_k_dup_func = (GBoxedCopyFunc(*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_gee_map_iterator_get_k_dup_func;
2859         iface->get_k_destroy_func = (GDestroyNotify(*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_gee_map_iterator_get_k_destroy_func;
2860         iface->get_v_type = (GType(*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_gee_map_iterator_get_v_type;
2861         iface->get_v_dup_func = (GBoxedCopyFunc(*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_gee_map_iterator_get_v_dup_func;
2862         iface->get_v_destroy_func = (GDestroyNotify(*)(GeeMapIterator*)) gee_abstract_multi_map_map_iterator_gee_map_iterator_get_v_destroy_func;
2863         iface->next = (gboolean (*)(GeeMapIterator*)) gee_abstract_multi_map_mapping_iterator_next;
2864         iface->has_next = (gboolean (*)(GeeMapIterator*)) gee_abstract_multi_map_mapping_iterator_has_next;
2865         iface->unset = (void (*)(GeeMapIterator*)) gee_abstract_multi_map_mapping_iterator_unset;
2866         iface->get_mutable = gee_abstract_multi_map_map_iterator_real_get_mutable;
2867         iface->get_valid = (gboolean (*) (GeeMapIterator *)) gee_abstract_multi_map_mapping_iterator_get_valid;
2868         iface->get_read_only = (gboolean (*) (GeeMapIterator *)) gee_abstract_multi_map_mapping_iterator_get_read_only;
2869 }
2870
2871
2872 static void gee_abstract_multi_map_map_iterator_instance_init (GeeAbstractMultiMapMapIterator * self) {
2873         self->priv = GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_GET_PRIVATE (self);
2874 }
2875
2876
2877 static GType gee_abstract_multi_map_map_iterator_get_type (void) {
2878         static volatile gsize gee_abstract_multi_map_map_iterator_type_id__volatile = 0;
2879         if (g_once_init_enter (&gee_abstract_multi_map_map_iterator_type_id__volatile)) {
2880                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiMapMapIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_map_map_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiMapMapIterator), 0, (GInstanceInitFunc) gee_abstract_multi_map_map_iterator_instance_init, NULL };
2881                 static const GInterfaceInfo gee_map_iterator_info = { (GInterfaceInitFunc) gee_abstract_multi_map_map_iterator_gee_map_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2882                 GType gee_abstract_multi_map_map_iterator_type_id;
2883                 gee_abstract_multi_map_map_iterator_type_id = g_type_register_static (GEE_ABSTRACT_MULTI_MAP_TYPE_MAPPING_ITERATOR, "GeeAbstractMultiMapMapIterator", &g_define_type_info, 0);
2884                 g_type_add_interface_static (gee_abstract_multi_map_map_iterator_type_id, GEE_TYPE_MAP_ITERATOR, &gee_map_iterator_info);
2885                 g_once_init_leave (&gee_abstract_multi_map_map_iterator_type_id__volatile, gee_abstract_multi_map_map_iterator_type_id);
2886         }
2887         return gee_abstract_multi_map_map_iterator_type_id__volatile;
2888 }
2889
2890
2891 static void _vala_gee_abstract_multi_map_map_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2892         GeeAbstractMultiMapMapIterator * self;
2893         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR, GeeAbstractMultiMapMapIterator);
2894         switch (property_id) {
2895                 case GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_MUTABLE:
2896                 g_value_set_boolean (value, gee_map_iterator_get_mutable ((GeeMapIterator*) self));
2897                 break;
2898                 default:
2899                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2900                 break;
2901         }
2902 }
2903
2904
2905 static void _vala_gee_abstract_multi_map_map_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2906         GeeAbstractMultiMapMapIterator * self;
2907         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_ABSTRACT_MULTI_MAP_TYPE_MAP_ITERATOR, GeeAbstractMultiMapMapIterator);
2908         switch (property_id) {
2909                 case GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_TYPE:
2910                 self->priv->k_type = g_value_get_gtype (value);
2911                 break;
2912                 case GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_DUP_FUNC:
2913                 self->priv->k_dup_func = g_value_get_pointer (value);
2914                 break;
2915                 case GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_K_DESTROY_FUNC:
2916                 self->priv->k_destroy_func = g_value_get_pointer (value);
2917                 break;
2918                 case GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_TYPE:
2919                 self->priv->v_type = g_value_get_gtype (value);
2920                 break;
2921                 case GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_DUP_FUNC:
2922                 self->priv->v_dup_func = g_value_get_pointer (value);
2923                 break;
2924                 case GEE_ABSTRACT_MULTI_MAP_MAP_ITERATOR_V_DESTROY_FUNC:
2925                 self->priv->v_destroy_func = g_value_get_pointer (value);
2926                 break;
2927                 default:
2928                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2929                 break;
2930         }
2931 }
2932
2933
2934 static void gee_abstract_multi_map_class_init (GeeAbstractMultiMapClass * klass) {
2935         gee_abstract_multi_map_parent_class = g_type_class_peek_parent (klass);
2936         g_type_class_add_private (klass, sizeof (GeeAbstractMultiMapPrivate));
2937         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->create_value_storage = gee_abstract_multi_map_real_create_value_storage;
2938         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->create_multi_key_set = gee_abstract_multi_map_real_create_multi_key_set;
2939         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->get_value_equal_func = gee_abstract_multi_map_real_get_value_equal_func;
2940         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved0 = gee_abstract_multi_map_real_reserved0;
2941         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved1 = gee_abstract_multi_map_real_reserved1;
2942         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved2 = gee_abstract_multi_map_real_reserved2;
2943         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved3 = gee_abstract_multi_map_real_reserved3;
2944         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved4 = gee_abstract_multi_map_real_reserved4;
2945         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved5 = gee_abstract_multi_map_real_reserved5;
2946         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved6 = gee_abstract_multi_map_real_reserved6;
2947         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved7 = gee_abstract_multi_map_real_reserved7;
2948         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->reserved8 = gee_abstract_multi_map_real_reserved8;
2949         GEE_ABSTRACT_MULTI_MAP_CLASS (klass)->get_read_only_view = gee_abstract_multi_map_real_get_read_only_view;
2950         G_OBJECT_CLASS (klass)->get_property = _vala_gee_abstract_multi_map_get_property;
2951         G_OBJECT_CLASS (klass)->set_property = _vala_gee_abstract_multi_map_set_property;
2952         G_OBJECT_CLASS (klass)->finalize = gee_abstract_multi_map_finalize;
2953         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_K_TYPE, g_param_spec_gtype ("k-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2954         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_K_DUP_FUNC, g_param_spec_pointer ("k-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2955         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_K_DESTROY_FUNC, g_param_spec_pointer ("k-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2956         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_V_TYPE, g_param_spec_gtype ("v-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2957         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_V_DUP_FUNC, g_param_spec_pointer ("v-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2958         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_V_DESTROY_FUNC, g_param_spec_pointer ("v-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2959         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2960         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_ABSTRACT_MULTI_MAP_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2961 }
2962
2963
2964 static GType gee_abstract_multi_map_gee_multi_map_get_k_type (GeeAbstractMultiMap* self) {
2965         return self->priv->k_type;
2966 }
2967
2968
2969 static GBoxedCopyFunc gee_abstract_multi_map_gee_multi_map_get_k_dup_func (GeeAbstractMultiMap* self) {
2970         return self->priv->k_dup_func;
2971 }
2972
2973
2974 static GDestroyNotify gee_abstract_multi_map_gee_multi_map_get_k_destroy_func (GeeAbstractMultiMap* self) {
2975         return self->priv->k_destroy_func;
2976 }
2977
2978
2979 static GType gee_abstract_multi_map_gee_multi_map_get_v_type (GeeAbstractMultiMap* self) {
2980         return self->priv->v_type;
2981 }
2982
2983
2984 static GBoxedCopyFunc gee_abstract_multi_map_gee_multi_map_get_v_dup_func (GeeAbstractMultiMap* self) {
2985         return self->priv->v_dup_func;
2986 }
2987
2988
2989 static GDestroyNotify gee_abstract_multi_map_gee_multi_map_get_v_destroy_func (GeeAbstractMultiMap* self) {
2990         return self->priv->v_destroy_func;
2991 }
2992
2993
2994 static void gee_abstract_multi_map_gee_multi_map_interface_init (GeeMultiMapIface * iface) {
2995         gee_abstract_multi_map_gee_multi_map_parent_iface = g_type_interface_peek_parent (iface);
2996         iface->get_keys = (GeeSet* (*)(GeeMultiMap*)) gee_abstract_multi_map_real_get_keys;
2997         iface->get_all_keys = (GeeMultiSet* (*)(GeeMultiMap*)) gee_abstract_multi_map_real_get_all_keys;
2998         iface->get_values = (GeeCollection* (*)(GeeMultiMap*)) gee_abstract_multi_map_real_get_values;
2999         iface->contains = (gboolean (*)(GeeMultiMap*, gconstpointer)) gee_abstract_multi_map_real_contains;
3000         iface->get = (GeeCollection* (*)(GeeMultiMap*, gconstpointer)) gee_abstract_multi_map_real_get;
3001         iface->set = (void (*)(GeeMultiMap*, gconstpointer, gconstpointer)) gee_abstract_multi_map_real_set;
3002         iface->remove = (gboolean (*)(GeeMultiMap*, gconstpointer, gconstpointer)) gee_abstract_multi_map_real_remove;
3003         iface->remove_all = (gboolean (*)(GeeMultiMap*, gconstpointer)) gee_abstract_multi_map_real_remove_all;
3004         iface->clear = (void (*)(GeeMultiMap*)) gee_abstract_multi_map_real_clear;
3005         iface->map_iterator = (GeeMapIterator* (*)(GeeMultiMap*)) gee_abstract_multi_map_real_map_iterator;
3006         iface->get_k_type = (GType(*)(GeeMultiMap*)) gee_abstract_multi_map_gee_multi_map_get_k_type;
3007         iface->get_k_dup_func = (GBoxedCopyFunc(*)(GeeMultiMap*)) gee_abstract_multi_map_gee_multi_map_get_k_dup_func;
3008         iface->get_k_destroy_func = (GDestroyNotify(*)(GeeMultiMap*)) gee_abstract_multi_map_gee_multi_map_get_k_destroy_func;
3009         iface->get_v_type = (GType(*)(GeeMultiMap*)) gee_abstract_multi_map_gee_multi_map_get_v_type;
3010         iface->get_v_dup_func = (GBoxedCopyFunc(*)(GeeMultiMap*)) gee_abstract_multi_map_gee_multi_map_get_v_dup_func;
3011         iface->get_v_destroy_func = (GDestroyNotify(*)(GeeMultiMap*)) gee_abstract_multi_map_gee_multi_map_get_v_destroy_func;
3012         iface->get_size = gee_abstract_multi_map_real_get_size;
3013         iface->get_read_only = gee_abstract_multi_map_real_get_read_only;
3014         iface->get_read_only_view = (GeeMultiMap* (*) (GeeMultiMap *)) gee_abstract_multi_map_get_read_only_view;
3015 }
3016
3017
3018 static void gee_abstract_multi_map_instance_init (GeeAbstractMultiMap * self) {
3019         self->priv = GEE_ABSTRACT_MULTI_MAP_GET_PRIVATE (self);
3020         self->priv->_nitems = 0;
3021 }
3022
3023
3024 static void gee_abstract_multi_map_finalize (GObject* obj) {
3025         GeeAbstractMultiMap * self;
3026         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_ABSTRACT_MULTI_MAP, GeeAbstractMultiMap);
3027         _g_object_unref0 (self->_storage_map);
3028         G_OBJECT_CLASS (gee_abstract_multi_map_parent_class)->finalize (obj);
3029 }
3030
3031
3032 /**
3033  * Skeletal implementation of the {@link MultiMap} interface.
3034  *
3035  * @see HashMultiMap
3036  * @see TreeMultiMap
3037  */
3038 GType gee_abstract_multi_map_get_type (void) {
3039         static volatile gsize gee_abstract_multi_map_type_id__volatile = 0;
3040         if (g_once_init_enter (&gee_abstract_multi_map_type_id__volatile)) {
3041                 static const GTypeInfo g_define_type_info = { sizeof (GeeAbstractMultiMapClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_abstract_multi_map_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeAbstractMultiMap), 0, (GInstanceInitFunc) gee_abstract_multi_map_instance_init, NULL };
3042                 static const GInterfaceInfo gee_multi_map_info = { (GInterfaceInitFunc) gee_abstract_multi_map_gee_multi_map_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
3043                 GType gee_abstract_multi_map_type_id;
3044                 gee_abstract_multi_map_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeAbstractMultiMap", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
3045                 g_type_add_interface_static (gee_abstract_multi_map_type_id, GEE_TYPE_MULTI_MAP, &gee_multi_map_info);
3046                 g_once_init_leave (&gee_abstract_multi_map_type_id__volatile, gee_abstract_multi_map_type_id);
3047         }
3048         return gee_abstract_multi_map_type_id__volatile;
3049 }
3050
3051
3052 static void _vala_gee_abstract_multi_map_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
3053         GeeAbstractMultiMap * self;
3054         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_ABSTRACT_MULTI_MAP, GeeAbstractMultiMap);
3055         switch (property_id) {
3056                 case GEE_ABSTRACT_MULTI_MAP_SIZE:
3057                 g_value_set_int (value, gee_multi_map_get_size ((GeeMultiMap*) self));
3058                 break;
3059                 case GEE_ABSTRACT_MULTI_MAP_READ_ONLY:
3060                 g_value_set_boolean (value, gee_multi_map_get_read_only ((GeeMultiMap*) self));
3061                 break;
3062                 default:
3063                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3064                 break;
3065         }
3066 }
3067
3068
3069 static void _vala_gee_abstract_multi_map_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3070         GeeAbstractMultiMap * self;
3071         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_ABSTRACT_MULTI_MAP, GeeAbstractMultiMap);
3072         switch (property_id) {
3073                 case GEE_ABSTRACT_MULTI_MAP_K_TYPE:
3074                 self->priv->k_type = g_value_get_gtype (value);
3075                 break;
3076                 case GEE_ABSTRACT_MULTI_MAP_K_DUP_FUNC:
3077                 self->priv->k_dup_func = g_value_get_pointer (value);
3078                 break;
3079                 case GEE_ABSTRACT_MULTI_MAP_K_DESTROY_FUNC:
3080                 self->priv->k_destroy_func = g_value_get_pointer (value);
3081                 break;
3082                 case GEE_ABSTRACT_MULTI_MAP_V_TYPE:
3083                 self->priv->v_type = g_value_get_gtype (value);
3084                 break;
3085                 case GEE_ABSTRACT_MULTI_MAP_V_DUP_FUNC:
3086                 self->priv->v_dup_func = g_value_get_pointer (value);
3087                 break;
3088                 case GEE_ABSTRACT_MULTI_MAP_V_DESTROY_FUNC:
3089                 self->priv->v_destroy_func = g_value_get_pointer (value);
3090                 break;
3091                 default:
3092                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3093                 break;
3094         }
3095 }
3096
3097
3098