gee/multimap.c

   1 /* multimap.c generated by valac 0.18.0, the Vala compiler
   2  * generated from multimap.vala, do not modify */
   3
   4 /* multimap.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  */
  25
  26 #include <glib.h>
  27 #include <glib-object.h>
  28
  29
  30 #define GEE_TYPE_MULTI_MAP (gee_multi_map_get_type ())
  31 #define GEE_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MULTI_MAP, GeeMultiMap))
  32 #define GEE_IS_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MULTI_MAP))
  33 #define GEE_MULTI_MAP_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MULTI_MAP, GeeMultiMapIface))
  34
  35 typedef struct _GeeMultiMap GeeMultiMap;
  36 typedef struct _GeeMultiMapIface GeeMultiMapIface;
  37
  38 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  39 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  40 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  41 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  42
  43 typedef struct _GeeTraversable GeeTraversable;
  44 typedef struct _GeeTraversableIface GeeTraversableIface;
  45
  46 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  47
  48 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  49 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  50 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  51 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  52 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  53 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  54
  55 typedef struct _GeeLazy GeeLazy;
  56 typedef struct _GeeLazyClass GeeLazyClass;
  57
  58 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  59 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  60 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  61 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  62
  63 typedef struct _GeeIterator GeeIterator;
  64 typedef struct _GeeIteratorIface GeeIteratorIface;
  65
  66 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  67 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  68 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  69 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  70
  71 typedef struct _GeeIterable GeeIterable;
  72 typedef struct _GeeIterableIface GeeIterableIface;
  73
  74 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  75 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  76 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  77 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  78
  79 typedef struct _GeeCollection GeeCollection;
  80 typedef struct _GeeCollectionIface GeeCollectionIface;
  81
  82 #define GEE_TYPE_SET (gee_set_get_type ())
  83 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
  84 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
  85 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
  86
  87 typedef struct _GeeSet GeeSet;
  88 typedef struct _GeeSetIface GeeSetIface;
  89
  90 #define GEE_TYPE_MULTI_SET (gee_multi_set_get_type ())
  91 #define GEE_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MULTI_SET, GeeMultiSet))
  92 #define GEE_IS_MULTI_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MULTI_SET))
  93 #define GEE_MULTI_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MULTI_SET, GeeMultiSetIface))
  94
  95 typedef struct _GeeMultiSet GeeMultiSet;
  96 typedef struct _GeeMultiSetIface GeeMultiSetIface;
  97
  98 #define GEE_TYPE_MAP_ITERATOR (gee_map_iterator_get_type ())
  99 #define GEE_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIterator))
 100 #define GEE_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_MAP_ITERATOR))
 101 #define GEE_MAP_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_MAP_ITERATOR, GeeMapIteratorIface))
 102
 103 typedef struct _GeeMapIterator GeeMapIterator;
 104 typedef struct _GeeMapIteratorIface GeeMapIteratorIface;
 105
 106 #define GEE_TYPE_READ_ONLY_MULTI_MAP (gee_read_only_multi_map_get_type ())
 107 #define GEE_READ_ONLY_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_MULTI_MAP, GeeReadOnlyMultiMap))
 108 #define GEE_READ_ONLY_MULTI_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_MULTI_MAP, GeeReadOnlyMultiMapClass))
 109 #define GEE_IS_READ_ONLY_MULTI_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_MULTI_MAP))
 110 #define GEE_IS_READ_ONLY_MULTI_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_MULTI_MAP))
 111 #define GEE_READ_ONLY_MULTI_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_MULTI_MAP, GeeReadOnlyMultiMapClass))
 112
 113 typedef struct _GeeReadOnlyMultiMap GeeReadOnlyMultiMap;
 114 typedef struct _GeeReadOnlyMultiMapClass GeeReadOnlyMultiMapClass;
 115
 116 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 117 typedef enum  {
 118         GEE_TRAVERSABLE_STREAM_YIELD,
 119         GEE_TRAVERSABLE_STREAM_CONTINUE,
 120         GEE_TRAVERSABLE_STREAM_END
 121 } GeeTraversableStream;
 122
 123 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 124 struct _GeeIteratorIface {
 125         GTypeInterface parent_iface;
 126         gboolean (*next) (GeeIterator* self);
 127         gboolean (*has_next) (GeeIterator* self);
 128         gpointer (*get) (GeeIterator* self);
 129         void (*remove) (GeeIterator* self);
 130         gboolean (*get_valid) (GeeIterator* self);
 131         gboolean (*get_read_only) (GeeIterator* self);
 132 };
 133
 134 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 135 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 136 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 137 struct _GeeTraversableIface {
 138         GTypeInterface parent_iface;
 139         GType (*get_g_type) (GeeTraversable* self);
 140         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 141         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 142         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 143         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);
 144         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 145         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 146         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 147         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 148         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 149         GType (*get_element_type) (GeeTraversable* self);
 150 };
 151
 152 struct _GeeIterableIface {
 153         GTypeInterface parent_iface;
 154         GType (*get_g_type) (GeeIterable* self);
 155         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 156         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 157         GeeIterator* (*iterator) (GeeIterable* self);
 158 };
 159
 160 struct _GeeCollectionIface {
 161         GTypeInterface parent_iface;
 162         GType (*get_g_type) (GeeCollection* self);
 163         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 164         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 165         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 166         gboolean (*add) (GeeCollection* self, gconstpointer item);
 167         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 168         void (*clear) (GeeCollection* self);
 169         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 170         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 171         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 172         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 173         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 174         gint (*get_size) (GeeCollection* self);
 175         gboolean (*get_is_empty) (GeeCollection* self);
 176         gboolean (*get_read_only) (GeeCollection* self);
 177         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 178 };
 179
 180 struct _GeeSetIface {
 181         GTypeInterface parent_iface;
 182         GType (*get_g_type) (GeeSet* self);
 183         GBoxedCopyFunc (*get_g_dup_func) (GeeSet* self);
 184         GDestroyNotify (*get_g_destroy_func) (GeeSet* self);
 185         GeeSet* (*get_read_only_view) (GeeSet* self);
 186 };
 187
 188 struct _GeeMultiSetIface {
 189         GTypeInterface parent_iface;
 190         GType (*get_g_type) (GeeMultiSet* self);
 191         GBoxedCopyFunc (*get_g_dup_func) (GeeMultiSet* self);
 192         GDestroyNotify (*get_g_destroy_func) (GeeMultiSet* self);
 193         gint (*count) (GeeMultiSet* self, gconstpointer item);
 194         GeeMultiSet* (*get_read_only_view) (GeeMultiSet* self);
 195 };
 196
 197 typedef gpointer (*GeeFoldMapFunc) (gconstpointer k, gconstpointer v, gpointer a, void* user_data);
 198 typedef gboolean (*GeeForallMapFunc) (gconstpointer k, gconstpointer v, void* user_data);
 199 struct _GeeMapIteratorIface {
 200         GTypeInterface parent_iface;
 201         GType (*get_k_type) (GeeMapIterator* self);
 202         GBoxedCopyFunc (*get_k_dup_func) (GeeMapIterator* self);
 203         GDestroyNotify (*get_k_destroy_func) (GeeMapIterator* self);
 204         GType (*get_v_type) (GeeMapIterator* self);
 205         GBoxedCopyFunc (*get_v_dup_func) (GeeMapIterator* self);
 206         GDestroyNotify (*get_v_destroy_func) (GeeMapIterator* self);
 207         gboolean (*next) (GeeMapIterator* self);
 208         gboolean (*has_next) (GeeMapIterator* self);
 209         gpointer (*get_key) (GeeMapIterator* self);
 210         gpointer (*get_value) (GeeMapIterator* self);
 211         void (*set_value) (GeeMapIterator* self, gconstpointer value);
 212         void (*unset) (GeeMapIterator* self);
 213         gpointer (*fold) (GeeMapIterator* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldMapFunc f, void* f_target, gpointer seed);
 214         gboolean (*foreach) (GeeMapIterator* self, GeeForallMapFunc f, void* f_target);
 215         gboolean (*get_valid) (GeeMapIterator* self);
 216         gboolean (*get_mutable) (GeeMapIterator* self);
 217         gboolean (*get_read_only) (GeeMapIterator* self);
 218 };
 219
 220 struct _GeeMultiMapIface {
 221         GTypeInterface parent_iface;
 222         GType (*get_k_type) (GeeMultiMap* self);
 223         GBoxedCopyFunc (*get_k_dup_func) (GeeMultiMap* self);
 224         GDestroyNotify (*get_k_destroy_func) (GeeMultiMap* self);
 225         GType (*get_v_type) (GeeMultiMap* self);
 226         GBoxedCopyFunc (*get_v_dup_func) (GeeMultiMap* self);
 227         GDestroyNotify (*get_v_destroy_func) (GeeMultiMap* self);
 228         GeeSet* (*get_keys) (GeeMultiMap* self);
 229         GeeMultiSet* (*get_all_keys) (GeeMultiMap* self);
 230         GeeCollection* (*get_values) (GeeMultiMap* self);
 231         gboolean (*contains) (GeeMultiMap* self, gconstpointer key);
 232         GeeCollection* (*get) (GeeMultiMap* self, gconstpointer key);
 233         void (*set) (GeeMultiMap* self, gconstpointer key, gconstpointer value);
 234         gboolean (*remove) (GeeMultiMap* self, gconstpointer key, gconstpointer value);
 235         gboolean (*remove_all) (GeeMultiMap* self, gconstpointer key);
 236         void (*clear) (GeeMultiMap* self);
 237         GeeMapIterator* (*map_iterator) (GeeMultiMap* self);
 238         gint (*get_size) (GeeMultiMap* self);
 239         gboolean (*get_read_only) (GeeMultiMap* self);
 240         GeeMultiMap* (*get_read_only_view) (GeeMultiMap* self);
 241 };
 242
 243
 244
 245 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 246 gpointer gee_lazy_ref (gpointer instance);
 247 void gee_lazy_unref (gpointer instance);
 248 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 249 void gee_value_set_lazy (GValue* value, gpointer v_object);
 250 void gee_value_take_lazy (GValue* value, gpointer v_object);
 251 gpointer gee_value_get_lazy (const GValue* value);
 252 GType gee_lazy_get_type (void) G_GNUC_CONST;
 253 GType gee_iterator_get_type (void) G_GNUC_CONST;
 254 GType gee_traversable_get_type (void) G_GNUC_CONST;
 255 GType gee_iterable_get_type (void) G_GNUC_CONST;
 256 GType gee_collection_get_type (void) G_GNUC_CONST;
 257 GType gee_set_get_type (void) G_GNUC_CONST;
 258 GType gee_multi_set_get_type (void) G_GNUC_CONST;
 259 GType gee_map_iterator_get_type (void) G_GNUC_CONST;
 260 GType gee_multi_map_get_type (void) G_GNUC_CONST;
 261 GeeSet* gee_multi_map_get_keys (GeeMultiMap* self);
 262 GeeMultiSet* gee_multi_map_get_all_keys (GeeMultiMap* self);
 263 GeeCollection* gee_multi_map_get_values (GeeMultiMap* self);
 264 gboolean gee_multi_map_contains (GeeMultiMap* self, gconstpointer key);
 265 GeeCollection* gee_multi_map_get (GeeMultiMap* self, gconstpointer key);
 266 void gee_multi_map_set (GeeMultiMap* self, gconstpointer key, gconstpointer value);
 267 gboolean gee_multi_map_remove (GeeMultiMap* self, gconstpointer key, gconstpointer value);
 268 gboolean gee_multi_map_remove_all (GeeMultiMap* self, gconstpointer key);
 269 void gee_multi_map_clear (GeeMultiMap* self);
 270 GeeMapIterator* gee_multi_map_map_iterator (GeeMultiMap* self);
 271 gint gee_multi_map_get_size (GeeMultiMap* self);
 272 gboolean gee_multi_map_get_read_only (GeeMultiMap* self);
 273 GType gee_multi_map_get_key_type (GeeMultiMap* self);
 274 GType gee_multi_map_get_value_type (GeeMultiMap* self);
 275 GeeMultiMap* gee_multi_map_get_read_only_view (GeeMultiMap* self);
 276 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);
 277 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);
 278 GType gee_read_only_multi_map_get_type (void) G_GNUC_CONST;
 279
 280
 281 /**
 282  * Returns the keys of this multimap as a read-only set.
 283  *
 284  * @return the keys of the map
 285  */
 286 GeeSet* gee_multi_map_get_keys (GeeMultiMap* self) {
 287         g_return_val_if_fail (self != NULL, NULL);
 288         return GEE_MULTI_MAP_GET_INTERFACE (self)->get_keys (self);
 289 }
 290
 291
 292 /**
 293  * Returns the keys of this multimap as a read-only set.
 294  *
 295  * @return the keys of the map
 296  */
 297 GeeMultiSet* gee_multi_map_get_all_keys (GeeMultiMap* self) {
 298         g_return_val_if_fail (self != NULL, NULL);
 299         return GEE_MULTI_MAP_GET_INTERFACE (self)->get_all_keys (self);
 300 }
 301
 302
 303 /**
 304  * Returns the values of this map as a read-only collection.
 305  *
 306  * @return the values of the map
 307  */
 308 GeeCollection* gee_multi_map_get_values (GeeMultiMap* self) {
 309         g_return_val_if_fail (self != NULL, NULL);
 310         return GEE_MULTI_MAP_GET_INTERFACE (self)->get_values (self);
 311 }
 312
 313
 314 /**
 315  * Determines whether this map contains the specified key.
 316  *
 317  * @param key the key to locate in the map
 318  *
 319  * @return    ``true`` if key is found, ``false`` otherwise
 320  */
 321 gboolean gee_multi_map_contains (GeeMultiMap* self, gconstpointer key) {
 322         g_return_val_if_fail (self != NULL, FALSE);
 323         return GEE_MULTI_MAP_GET_INTERFACE (self)->contains (self, key);
 324 }
 325
 326
 327 /**
 328  * Returns the values for the specified key in this map.
 329  *
 330  * @param key the key whose values are to be retrieved
 331  *
 332  * @return    a Collection of values associated with the given key
 333  */
 334 GeeCollection* gee_multi_map_get (GeeMultiMap* self, gconstpointer key) {
 335         g_return_val_if_fail (self != NULL, NULL);
 336         return GEE_MULTI_MAP_GET_INTERFACE (self)->get (self, key);
 337 }
 338
 339
 340 /**
 341  * Inserts a key/value pair into this map.
 342  *
 343  * @param key   the key to insert
 344  * @param value the value to associate with the key
 345  */
 346 void gee_multi_map_set (GeeMultiMap* self, gconstpointer key, gconstpointer value) {
 347         g_return_if_fail (self != NULL);
 348         GEE_MULTI_MAP_GET_INTERFACE (self)->set (self, key, value);
 349 }
 350
 351
 352 /**
 353  * Removes the specified key/value pair from this multimap.
 354  *
 355  * @param key   the key to remove from the map
 356  * @param value the value to remove from the map
 357  *
 358  * @return      ``true`` if the map has been changed, ``false`` otherwise
 359  */
 360 gboolean gee_multi_map_remove (GeeMultiMap* self, gconstpointer key, gconstpointer value) {
 361         g_return_val_if_fail (self != NULL, FALSE);
 362         return GEE_MULTI_MAP_GET_INTERFACE (self)->remove (self, key, value);
 363 }
 364
 365
 366 /**
 367  * Removes the specified key and all the associated values from this
 368  * multimap.
 369  *
 370  * @param key the key to remove from the map
 371  *
 372  * @return    ``true`` if the map has been changed, ``false`` otherwise
 373  */
 374 gboolean gee_multi_map_remove_all (GeeMultiMap* self, gconstpointer key) {
 375         g_return_val_if_fail (self != NULL, FALSE);
 376         return GEE_MULTI_MAP_GET_INTERFACE (self)->remove_all (self, key);
 377 }
 378
 379
 380 /**
 381  * Removes all items from this collection.
 382  */
 383 void gee_multi_map_clear (GeeMultiMap* self) {
 384         g_return_if_fail (self != NULL);
 385         GEE_MULTI_MAP_GET_INTERFACE (self)->clear (self);
 386 }
 387
 388
 389 /**
 390  * Returns an iterator for this map.
 391  *
 392  * @return a map iterator
 393  */
 394 GeeMapIterator* gee_multi_map_map_iterator (GeeMultiMap* self) {
 395         g_return_val_if_fail (self != NULL, NULL);
 396         return GEE_MULTI_MAP_GET_INTERFACE (self)->map_iterator (self);
 397 }
 398
 399
 400 gint gee_multi_map_get_size (GeeMultiMap* self) {
 401         g_return_val_if_fail (self != NULL, 0);
 402         return GEE_MULTI_MAP_GET_INTERFACE (self)->get_size (self);
 403 }
 404
 405
 406 gboolean gee_multi_map_get_read_only (GeeMultiMap* self) {
 407         g_return_val_if_fail (self != NULL, FALSE);
 408         return GEE_MULTI_MAP_GET_INTERFACE (self)->get_read_only (self);
 409 }
 410
 411
 412 GType gee_multi_map_get_key_type (GeeMultiMap* self) {
 413         GType result;
 414         g_return_val_if_fail (self != NULL, 0UL);
 415         result = GEE_MULTI_MAP_GET_INTERFACE (self)->get_k_type (self);
 416         return result;
 417 }
 418
 419
 420 GType gee_multi_map_get_value_type (GeeMultiMap* self) {
 421         GType result;
 422         g_return_val_if_fail (self != NULL, 0UL);
 423         result = GEE_MULTI_MAP_GET_INTERFACE (self)->get_v_type (self);
 424         return result;
 425 }
 426
 427
 428 GeeMultiMap* gee_multi_map_get_read_only_view (GeeMultiMap* self) {
 429         g_return_val_if_fail (self != NULL, NULL);
 430         return GEE_MULTI_MAP_GET_INTERFACE (self)->get_read_only_view (self);
 431 }
 432
 433
 434 static GeeMultiMap* gee_multi_map_real_get_read_only_view (GeeMultiMap* base) {
 435         GeeMultiMap* result;
 436         GeeMultiMap* self;
 437         GeeReadOnlyMultiMap* _tmp0_;
 438         self = base;
 439         _tmp0_ = gee_read_only_multi_map_new (GEE_MULTI_MAP_GET_INTERFACE (self)->get_k_type (self), (GBoxedCopyFunc) GEE_MULTI_MAP_GET_INTERFACE (self)->get_k_dup_func (self), GEE_MULTI_MAP_GET_INTERFACE (self)->get_k_destroy_func (self), GEE_MULTI_MAP_GET_INTERFACE (self)->get_v_type (self), (GBoxedCopyFunc) GEE_MULTI_MAP_GET_INTERFACE (self)->get_v_dup_func (self), GEE_MULTI_MAP_GET_INTERFACE (self)->get_v_destroy_func (self), self);
 440         result = (GeeMultiMap*) _tmp0_;
 441         return result;
 442 }
 443
 444
 445 static void gee_multi_map_base_init (GeeMultiMapIface * iface) {
 446         static gboolean initialized = FALSE;
 447         if (!initialized) {
 448                 initialized = TRUE;
 449                 /**
 450                  * The number of key/value pairs in this map.
 451                  */
 452                 g_object_interface_install_property (iface, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 453                 /**
 454                  * Specifies whether this collection can change - i.e. wheather {@link set},
 455                  * {@link remove} etc. are legal operations.
 456                  */
 457                 g_object_interface_install_property (iface, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 458                 iface->get_read_only_view = gee_multi_map_real_get_read_only_view;
 459         }
 460 }
 461
 462
 463 /**
 464  * A map with multiple values per key.
 465  */
 466 GType gee_multi_map_get_type (void) {
 467         static volatile gsize gee_multi_map_type_id__volatile = 0;
 468         if (g_once_init_enter (&gee_multi_map_type_id__volatile)) {
 469                 static const GTypeInfo g_define_type_info = { sizeof (GeeMultiMapIface), (GBaseInitFunc) gee_multi_map_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
 470                 GType gee_multi_map_type_id;
 471                 gee_multi_map_type_id = g_type_register_static (G_TYPE_INTERFACE, "GeeMultiMap", &g_define_type_info, 0);
 472                 g_type_interface_add_prerequisite (gee_multi_map_type_id, G_TYPE_OBJECT);
 473                 g_once_init_leave (&gee_multi_map_type_id__volatile, gee_multi_map_type_id);
 474         }
 475         return gee_multi_map_type_id__volatile;
 476 }
 477
 478
 479