gee/readonlycollection.c

   1 /* readonlycollection.c generated by valac 0.18.0, the Vala compiler
   2  * generated from readonlycollection.vala, do not modify */
   3
   4 /* readonlycollection.vala
   5  *
   6  * Copyright (C) 2007-2008  Jürg Billeter
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  21  *
  22  * Author:
  23  *      Jürg Billeter <j@bitron.ch>
  24  */
  25
  26 #include <glib.h>
  27 #include <glib-object.h>
  28
  29
  30 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  31 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  32 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  33 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  34
  35 typedef struct _GeeTraversable GeeTraversable;
  36 typedef struct _GeeTraversableIface GeeTraversableIface;
  37
  38 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  39
  40 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  41 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  42 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  43 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  44 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  45 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  46
  47 typedef struct _GeeLazy GeeLazy;
  48 typedef struct _GeeLazyClass GeeLazyClass;
  49
  50 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  51 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  52 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  53 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  54
  55 typedef struct _GeeIterator GeeIterator;
  56 typedef struct _GeeIteratorIface GeeIteratorIface;
  57
  58 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  59 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  60 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  61 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  62
  63 typedef struct _GeeIterable GeeIterable;
  64 typedef struct _GeeIterableIface GeeIterableIface;
  65
  66 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  67 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  68 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  69 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  70
  71 typedef struct _GeeCollection GeeCollection;
  72 typedef struct _GeeCollectionIface GeeCollectionIface;
  73
  74 #define GEE_TYPE_READ_ONLY_COLLECTION (gee_read_only_collection_get_type ())
  75 #define GEE_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection))
  76 #define GEE_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
  77 #define GEE_IS_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_COLLECTION))
  78 #define GEE_IS_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_COLLECTION))
  79 #define GEE_READ_ONLY_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
  80
  81 typedef struct _GeeReadOnlyCollection GeeReadOnlyCollection;
  82 typedef struct _GeeReadOnlyCollectionClass GeeReadOnlyCollectionClass;
  83 typedef struct _GeeReadOnlyCollectionPrivate GeeReadOnlyCollectionPrivate;
  84 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  85
  86 #define GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR (gee_read_only_collection_iterator_get_type ())
  87 #define GEE_READ_ONLY_COLLECTION_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator))
  88 #define GEE_READ_ONLY_COLLECTION_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIteratorClass))
  89 #define GEE_READ_ONLY_COLLECTION_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR))
  90 #define GEE_READ_ONLY_COLLECTION_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR))
  91 #define GEE_READ_ONLY_COLLECTION_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIteratorClass))
  92
  93 typedef struct _GeeReadOnlyCollectionIterator GeeReadOnlyCollectionIterator;
  94 typedef struct _GeeReadOnlyCollectionIteratorClass GeeReadOnlyCollectionIteratorClass;
  95 typedef struct _GeeReadOnlyCollectionIteratorPrivate GeeReadOnlyCollectionIteratorPrivate;
  96
  97 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
  98 typedef enum  {
  99         GEE_TRAVERSABLE_STREAM_YIELD,
 100         GEE_TRAVERSABLE_STREAM_CONTINUE,
 101         GEE_TRAVERSABLE_STREAM_END
 102 } GeeTraversableStream;
 103
 104 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 105 struct _GeeIteratorIface {
 106         GTypeInterface parent_iface;
 107         gboolean (*next) (GeeIterator* self);
 108         gboolean (*has_next) (GeeIterator* self);
 109         gpointer (*get) (GeeIterator* self);
 110         void (*remove) (GeeIterator* self);
 111         gboolean (*get_valid) (GeeIterator* self);
 112         gboolean (*get_read_only) (GeeIterator* self);
 113 };
 114
 115 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 116 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 117 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 118 struct _GeeTraversableIface {
 119         GTypeInterface parent_iface;
 120         GType (*get_g_type) (GeeTraversable* self);
 121         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 122         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 123         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 124         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);
 125         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 126         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 127         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 128         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 129         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 130         GType (*get_element_type) (GeeTraversable* self);
 131 };
 132
 133 struct _GeeIterableIface {
 134         GTypeInterface parent_iface;
 135         GType (*get_g_type) (GeeIterable* self);
 136         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 137         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 138         GeeIterator* (*iterator) (GeeIterable* self);
 139 };
 140
 141 struct _GeeCollectionIface {
 142         GTypeInterface parent_iface;
 143         GType (*get_g_type) (GeeCollection* self);
 144         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 145         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 146         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 147         gboolean (*add) (GeeCollection* self, gconstpointer item);
 148         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 149         void (*clear) (GeeCollection* self);
 150         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 151         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 152         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 153         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 154         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 155         gint (*get_size) (GeeCollection* self);
 156         gboolean (*get_is_empty) (GeeCollection* self);
 157         gboolean (*get_read_only) (GeeCollection* self);
 158         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 159 };
 160
 161 struct _GeeReadOnlyCollection {
 162         GObject parent_instance;
 163         GeeReadOnlyCollectionPrivate * priv;
 164         GeeCollection* _collection;
 165 };
 166
 167 struct _GeeReadOnlyCollectionClass {
 168         GObjectClass parent_class;
 169         GeeCollection* (*get_read_only_view) (GeeReadOnlyCollection* self);
 170 };
 171
 172 struct _GeeReadOnlyCollectionPrivate {
 173         GType g_type;
 174         GBoxedCopyFunc g_dup_func;
 175         GDestroyNotify g_destroy_func;
 176 };
 177
 178 struct _GeeReadOnlyCollectionIterator {
 179         GObject parent_instance;
 180         GeeReadOnlyCollectionIteratorPrivate * priv;
 181         GeeIterator* _iter;
 182 };
 183
 184 struct _GeeReadOnlyCollectionIteratorClass {
 185         GObjectClass parent_class;
 186 };
 187
 188 struct _GeeReadOnlyCollectionIteratorPrivate {
 189         GType g_type;
 190         GBoxedCopyFunc g_dup_func;
 191         GDestroyNotify g_destroy_func;
 192 };
 193
 194
 195 static gpointer gee_read_only_collection_parent_class = NULL;
 196 static gpointer gee_read_only_collection_iterator_parent_class = NULL;
 197 static GeeTraversableIface* gee_read_only_collection_iterator_gee_traversable_parent_iface = NULL;
 198 static GeeIteratorIface* gee_read_only_collection_iterator_gee_iterator_parent_iface = NULL;
 199 static GeeTraversableIface* gee_read_only_collection_gee_traversable_parent_iface = NULL;
 200 static GeeIterableIface* gee_read_only_collection_gee_iterable_parent_iface = NULL;
 201 static GeeCollectionIface* gee_read_only_collection_gee_collection_parent_iface = NULL;
 202
 203 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 204 gpointer gee_lazy_ref (gpointer instance);
 205 void gee_lazy_unref (gpointer instance);
 206 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 207 void gee_value_set_lazy (GValue* value, gpointer v_object);
 208 void gee_value_take_lazy (GValue* value, gpointer v_object);
 209 gpointer gee_value_get_lazy (const GValue* value);
 210 GType gee_lazy_get_type (void) G_GNUC_CONST;
 211 GType gee_iterator_get_type (void) G_GNUC_CONST;
 212 GType gee_traversable_get_type (void) G_GNUC_CONST;
 213 GType gee_iterable_get_type (void) G_GNUC_CONST;
 214 GType gee_collection_get_type (void) G_GNUC_CONST;
 215 GType gee_read_only_collection_get_type (void) G_GNUC_CONST;
 216 #define GEE_READ_ONLY_COLLECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionPrivate))
 217 enum  {
 218         GEE_READ_ONLY_COLLECTION_DUMMY_PROPERTY,
 219         GEE_READ_ONLY_COLLECTION_G_TYPE,
 220         GEE_READ_ONLY_COLLECTION_G_DUP_FUNC,
 221         GEE_READ_ONLY_COLLECTION_G_DESTROY_FUNC,
 222         GEE_READ_ONLY_COLLECTION_SIZE,
 223         GEE_READ_ONLY_COLLECTION_READ_ONLY,
 224         GEE_READ_ONLY_COLLECTION_READ_ONLY_VIEW
 225 };
 226 GeeReadOnlyCollection* gee_read_only_collection_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeCollection* collection);
 227 GeeReadOnlyCollection* gee_read_only_collection_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeCollection* collection);
 228 static gboolean gee_read_only_collection_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 229 gboolean gee_traversable_foreach (GeeTraversable* self, GeeForallFunc f, void* f_target);
 230 static GeeIterator* gee_read_only_collection_real_stream (GeeTraversable* base, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 231 GeeIterator* gee_traversable_stream (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 232 static GeeIterator* gee_read_only_collection_real_filter (GeeTraversable* base, GeePredicate f, void* f_target, GDestroyNotify f_target_destroy_notify);
 233 GeeIterator* gee_traversable_filter (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 234 static GeeIterator* gee_read_only_collection_real_chop (GeeTraversable* base, gint offset, gint length);
 235 GeeIterator* gee_traversable_chop (GeeTraversable* self, gint offset, gint length);
 236 static GeeIterator* gee_read_only_collection_real_iterator (GeeIterable* base);
 237 GeeIterator* gee_iterable_iterator (GeeIterable* self);
 238 GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeIterator* iterator);
 239 GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeIterator* iterator);
 240 GType gee_read_only_collection_iterator_get_type (void) G_GNUC_CONST;
 241 static gboolean gee_read_only_collection_real_contains (GeeCollection* base, gconstpointer item);
 242 gboolean gee_collection_contains (GeeCollection* self, gconstpointer item);
 243 static gboolean gee_read_only_collection_real_add (GeeCollection* base, gconstpointer item);
 244 static gboolean gee_read_only_collection_real_remove (GeeCollection* base, gconstpointer item);
 245 static void gee_read_only_collection_real_clear (GeeCollection* base);
 246 static gboolean gee_read_only_collection_real_add_all (GeeCollection* base, GeeCollection* collection);
 247 static gboolean gee_read_only_collection_real_contains_all (GeeCollection* base, GeeCollection* collection);
 248 gboolean gee_collection_contains_all (GeeCollection* self, GeeCollection* collection);
 249 static gboolean gee_read_only_collection_real_remove_all (GeeCollection* base, GeeCollection* collection);
 250 static gboolean gee_read_only_collection_real_retain_all (GeeCollection* base, GeeCollection* collection);
 251 static gpointer* gee_read_only_collection_real_to_array (GeeCollection* base, int* result_length1);
 252 gpointer* gee_collection_to_array (GeeCollection* self, int* result_length1);
 253 gint gee_collection_get_size (GeeCollection* self);
 254 gboolean gee_collection_get_is_empty (GeeCollection* self);
 255 GeeCollection* gee_read_only_collection_get_read_only_view (GeeReadOnlyCollection* self);
 256 #define GEE_READ_ONLY_COLLECTION_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIteratorPrivate))
 257 enum  {
 258         GEE_READ_ONLY_COLLECTION_ITERATOR_DUMMY_PROPERTY,
 259         GEE_READ_ONLY_COLLECTION_ITERATOR_G_TYPE,
 260         GEE_READ_ONLY_COLLECTION_ITERATOR_G_DUP_FUNC,
 261         GEE_READ_ONLY_COLLECTION_ITERATOR_G_DESTROY_FUNC,
 262         GEE_READ_ONLY_COLLECTION_ITERATOR_VALID,
 263         GEE_READ_ONLY_COLLECTION_ITERATOR_READ_ONLY
 264 };
 265 static gboolean gee_read_only_collection_iterator_real_next (GeeIterator* base);
 266 gboolean gee_iterator_next (GeeIterator* self);
 267 static gboolean gee_read_only_collection_iterator_real_has_next (GeeIterator* base);
 268 gboolean gee_iterator_has_next (GeeIterator* self);
 269 static gpointer gee_read_only_collection_iterator_real_get (GeeIterator* base);
 270 gpointer gee_iterator_get (GeeIterator* self);
 271 static void gee_read_only_collection_iterator_real_remove (GeeIterator* base);
 272 static gboolean gee_read_only_collection_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 273 static GeeIterator* gee_read_only_collection_iterator_real_stream (GeeTraversable* base, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 274 static GeeIterator* gee_read_only_collection_iterator_real_filter (GeeTraversable* base, GeePredicate f, void* f_target, GDestroyNotify f_target_destroy_notify);
 275 static GeeIterator* gee_read_only_collection_iterator_real_chop (GeeTraversable* base, gint offset, gint length);
 276 gboolean gee_iterator_get_valid (GeeIterator* self);
 277 static void gee_read_only_collection_iterator_finalize (GObject* obj);
 278 gboolean gee_iterator_get_read_only (GeeIterator* self);
 279 static void _vala_gee_read_only_collection_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 280 static void _vala_gee_read_only_collection_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 281 static void gee_read_only_collection_finalize (GObject* obj);
 282 gboolean gee_collection_get_read_only (GeeCollection* self);
 283 static void _vala_gee_read_only_collection_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 284 static void _vala_gee_read_only_collection_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 285
 286
 287 /**
 288  * Constructs a read-only collection that mirrors the content of the
 289  * specified collection.
 290  *
 291  * @param collection the collection to decorate.
 292  */
 293 static gpointer _g_object_ref0 (gpointer self) {
 294         return self ? g_object_ref (self) : NULL;
 295 }
 296
 297
 298 GeeReadOnlyCollection* gee_read_only_collection_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeCollection* collection) {
 299         GeeReadOnlyCollection * self = NULL;
 300         GeeCollection* _tmp0_;
 301         GeeCollection* _tmp1_;
 302         g_return_val_if_fail (collection != NULL, NULL);
 303         self = (GeeReadOnlyCollection*) g_object_new (object_type, NULL);
 304         self->priv->g_type = g_type;
 305         self->priv->g_dup_func = g_dup_func;
 306         self->priv->g_destroy_func = g_destroy_func;
 307         _tmp0_ = collection;
 308         _tmp1_ = _g_object_ref0 (_tmp0_);
 309         _g_object_unref0 (self->_collection);
 310         self->_collection = _tmp1_;
 311         return self;
 312 }
 313
 314
 315 GeeReadOnlyCollection* gee_read_only_collection_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeCollection* collection) {
 316         return gee_read_only_collection_construct (GEE_TYPE_READ_ONLY_COLLECTION, g_type, g_dup_func, g_destroy_func, collection);
 317 }
 318
 319
 320 /**
 321  * {@inheritDoc}
 322  */
 323 static gboolean gee_read_only_collection_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
 324         GeeReadOnlyCollection * self;
 325         gboolean result = FALSE;
 326         GeeCollection* _tmp0_;
 327         GeeForallFunc _tmp1_;
 328         void* _tmp1__target;
 329         gboolean _tmp2_ = FALSE;
 330         self = (GeeReadOnlyCollection*) base;
 331         _tmp0_ = self->_collection;
 332         _tmp1_ = f;
 333         _tmp1__target = f_target;
 334         _tmp2_ = gee_traversable_foreach ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target);
 335         result = _tmp2_;
 336         return result;
 337 }
 338
 339
 340 /**
 341  * {@inheritDoc}
 342  */
 343 static GeeIterator* gee_read_only_collection_real_stream (GeeTraversable* base, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 344         GeeReadOnlyCollection * self;
 345         GeeIterator* result = NULL;
 346         GeeCollection* _tmp0_;
 347         GeeStreamFunc _tmp1_;
 348         void* _tmp1__target;
 349         GDestroyNotify _tmp1__target_destroy_notify;
 350         GeeIterator* _tmp2_ = NULL;
 351         self = (GeeReadOnlyCollection*) base;
 352         _tmp0_ = self->_collection;
 353         _tmp1_ = f;
 354         _tmp1__target = f_target;
 355         _tmp1__target_destroy_notify = f_target_destroy_notify;
 356         f_target_destroy_notify = NULL;
 357         _tmp2_ = gee_traversable_stream ((GeeTraversable*) _tmp0_, a_type, (GBoxedCopyFunc) a_dup_func, a_destroy_func, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
 358         result = _tmp2_;
 359         (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
 360         f = NULL;
 361         f_target = NULL;
 362         f_target_destroy_notify = NULL;
 363         return result;
 364 }
 365
 366
 367 /**
 368  * {@inheritDoc}
 369  */
 370 static GeeIterator* gee_read_only_collection_real_filter (GeeTraversable* base, GeePredicate f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 371         GeeReadOnlyCollection * self;
 372         GeeIterator* result = NULL;
 373         GeeCollection* _tmp0_;
 374         GeePredicate _tmp1_;
 375         void* _tmp1__target;
 376         GDestroyNotify _tmp1__target_destroy_notify;
 377         GeeIterator* _tmp2_ = NULL;
 378         self = (GeeReadOnlyCollection*) base;
 379         _tmp0_ = self->_collection;
 380         _tmp1_ = f;
 381         _tmp1__target = f_target;
 382         _tmp1__target_destroy_notify = f_target_destroy_notify;
 383         f_target_destroy_notify = NULL;
 384         _tmp2_ = gee_traversable_filter ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
 385         result = _tmp2_;
 386         (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
 387         f = NULL;
 388         f_target = NULL;
 389         f_target_destroy_notify = NULL;
 390         return result;
 391 }
 392
 393
 394 /**
 395  * {@inheritDoc}
 396  */
 397 static GeeIterator* gee_read_only_collection_real_chop (GeeTraversable* base, gint offset, gint length) {
 398         GeeReadOnlyCollection * self;
 399         GeeIterator* result = NULL;
 400         GeeCollection* _tmp0_;
 401         gint _tmp1_;
 402         gint _tmp2_;
 403         GeeIterator* _tmp3_ = NULL;
 404         self = (GeeReadOnlyCollection*) base;
 405         _tmp0_ = self->_collection;
 406         _tmp1_ = offset;
 407         _tmp2_ = length;
 408         _tmp3_ = gee_traversable_chop ((GeeTraversable*) _tmp0_, _tmp1_, _tmp2_);
 409         result = _tmp3_;
 410         return result;
 411 }
 412
 413
 414 /**
 415  * {@inheritDoc}
 416  */
 417 static GeeIterator* gee_read_only_collection_real_iterator (GeeIterable* base) {
 418         GeeReadOnlyCollection * self;
 419         GeeIterator* result = NULL;
 420         GeeCollection* _tmp0_;
 421         GeeIterator* _tmp1_ = NULL;
 422         GeeIterator* _tmp2_;
 423         GeeReadOnlyCollectionIterator* _tmp3_;
 424         GeeIterator* _tmp4_;
 425         self = (GeeReadOnlyCollection*) base;
 426         _tmp0_ = self->_collection;
 427         _tmp1_ = gee_iterable_iterator ((GeeIterable*) _tmp0_);
 428         _tmp2_ = _tmp1_;
 429         _tmp3_ = gee_read_only_collection_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp2_);
 430         _tmp4_ = (GeeIterator*) _tmp3_;
 431         _g_object_unref0 (_tmp2_);
 432         result = _tmp4_;
 433         return result;
 434 }
 435
 436
 437 /**
 438  * {@inheritDoc}
 439  */
 440 static gboolean gee_read_only_collection_real_contains (GeeCollection* base, gconstpointer item) {
 441         GeeReadOnlyCollection * self;
 442         gboolean result = FALSE;
 443         GeeCollection* _tmp0_;
 444         gconstpointer _tmp1_;
 445         gboolean _tmp2_ = FALSE;
 446         self = (GeeReadOnlyCollection*) base;
 447         _tmp0_ = self->_collection;
 448         _tmp1_ = item;
 449         _tmp2_ = gee_collection_contains (_tmp0_, _tmp1_);
 450         result = _tmp2_;
 451         return result;
 452 }
 453
 454
 455 /**
 456  * Unimplemented method (read only collection).
 457  */
 458 static gboolean gee_read_only_collection_real_add (GeeCollection* base, gconstpointer item) {
 459         GeeReadOnlyCollection * self;
 460         gboolean result = FALSE;
 461         self = (GeeReadOnlyCollection*) base;
 462         g_assert_not_reached ();
 463         return result;
 464 }
 465
 466
 467 /**
 468  * Unimplemented method (read only collection).
 469  */
 470 static gboolean gee_read_only_collection_real_remove (GeeCollection* base, gconstpointer item) {
 471         GeeReadOnlyCollection * self;
 472         gboolean result = FALSE;
 473         self = (GeeReadOnlyCollection*) base;
 474         g_assert_not_reached ();
 475         return result;
 476 }
 477
 478
 479 /**
 480  * Unimplemented method (read only collection).
 481  */
 482 static void gee_read_only_collection_real_clear (GeeCollection* base) {
 483         GeeReadOnlyCollection * self;
 484         self = (GeeReadOnlyCollection*) base;
 485         g_assert_not_reached ();
 486 }
 487
 488
 489 /**
 490  * Unimplemented method (read only collection).
 491  */
 492 static gboolean gee_read_only_collection_real_add_all (GeeCollection* base, GeeCollection* collection) {
 493         GeeReadOnlyCollection * self;
 494         gboolean result = FALSE;
 495         self = (GeeReadOnlyCollection*) base;
 496         g_return_val_if_fail (collection != NULL, FALSE);
 497         g_assert_not_reached ();
 498         return result;
 499 }
 500
 501
 502 /**
 503  * {@inheritDoc}
 504  */
 505 static gboolean gee_read_only_collection_real_contains_all (GeeCollection* base, GeeCollection* collection) {
 506         GeeReadOnlyCollection * self;
 507         gboolean result = FALSE;
 508         GeeCollection* _tmp0_;
 509         GeeCollection* _tmp1_;
 510         gboolean _tmp2_ = FALSE;
 511         self = (GeeReadOnlyCollection*) base;
 512         g_return_val_if_fail (collection != NULL, FALSE);
 513         _tmp0_ = self->_collection;
 514         _tmp1_ = collection;
 515         _tmp2_ = gee_collection_contains_all (_tmp0_, _tmp1_);
 516         result = _tmp2_;
 517         return result;
 518 }
 519
 520
 521 /**
 522  * Unimplemented method (read only collection).
 523  */
 524 static gboolean gee_read_only_collection_real_remove_all (GeeCollection* base, GeeCollection* collection) {
 525         GeeReadOnlyCollection * self;
 526         gboolean result = FALSE;
 527         self = (GeeReadOnlyCollection*) base;
 528         g_return_val_if_fail (collection != NULL, FALSE);
 529         g_assert_not_reached ();
 530         return result;
 531 }
 532
 533
 534 /**
 535  * Unimplemented method (read only collection).
 536  */
 537 static gboolean gee_read_only_collection_real_retain_all (GeeCollection* base, GeeCollection* collection) {
 538         GeeReadOnlyCollection * self;
 539         gboolean result = FALSE;
 540         self = (GeeReadOnlyCollection*) base;
 541         g_return_val_if_fail (collection != NULL, FALSE);
 542         g_assert_not_reached ();
 543         return result;
 544 }
 545
 546
 547 /**
 548  * {@inheritDoc}
 549  */
 550 static gpointer* gee_read_only_collection_real_to_array (GeeCollection* base, int* result_length1) {
 551         GeeReadOnlyCollection * self;
 552         gpointer* result = NULL;
 553         GeeCollection* _tmp0_;
 554         gint _tmp1_ = 0;
 555         gpointer* _tmp2_ = NULL;
 556         gpointer* _tmp3_;
 557         gint _tmp3__length1;
 558         self = (GeeReadOnlyCollection*) base;
 559         _tmp0_ = self->_collection;
 560         _tmp2_ = gee_collection_to_array (_tmp0_, &_tmp1_);
 561         _tmp3_ = _tmp2_;
 562         _tmp3__length1 = _tmp1_;
 563         if (result_length1) {
 564                 *result_length1 = _tmp3__length1;
 565         }
 566         result = _tmp3_;
 567         return result;
 568 }
 569
 570
 571 static gint gee_read_only_collection_real_get_size (GeeCollection* base) {
 572         gint result;
 573         GeeReadOnlyCollection* self;
 574         GeeCollection* _tmp0_;
 575         gint _tmp1_;
 576         gint _tmp2_;
 577         self = (GeeReadOnlyCollection*) base;
 578         _tmp0_ = self->_collection;
 579         _tmp1_ = gee_collection_get_size (_tmp0_);
 580         _tmp2_ = _tmp1_;
 581         result = _tmp2_;
 582         return result;
 583 }
 584
 585
 586 static gboolean gee_read_only_collection_real_get_is_empty (GeeCollection* base) {
 587         gboolean result;
 588         GeeReadOnlyCollection* self;
 589         GeeCollection* _tmp0_;
 590         gboolean _tmp1_;
 591         gboolean _tmp2_;
 592         self = (GeeReadOnlyCollection*) base;
 593         _tmp0_ = self->_collection;
 594         _tmp1_ = gee_collection_get_is_empty (_tmp0_);
 595         _tmp2_ = _tmp1_;
 596         result = _tmp2_;
 597         return result;
 598 }
 599
 600
 601 static gboolean gee_read_only_collection_real_get_read_only (GeeCollection* base) {
 602         gboolean result;
 603         GeeReadOnlyCollection* self;
 604         self = (GeeReadOnlyCollection*) base;
 605         result = TRUE;
 606         return result;
 607 }
 608
 609
 610 static GType gee_read_only_collection_real_get_element_type (GeeTraversable* base) {
 611         GType result;
 612         GeeReadOnlyCollection* self;
 613         self = (GeeReadOnlyCollection*) base;
 614         result = self->priv->g_type;
 615         return result;
 616 }
 617
 618
 619 GeeCollection* gee_read_only_collection_get_read_only_view (GeeReadOnlyCollection* self) {
 620         g_return_val_if_fail (self != NULL, NULL);
 621         return GEE_READ_ONLY_COLLECTION_GET_CLASS (self)->get_read_only_view (self);
 622 }
 623
 624
 625 static GeeCollection* gee_read_only_collection_real_get_read_only_view (GeeReadOnlyCollection* base) {
 626         GeeCollection* result;
 627         GeeReadOnlyCollection* self;
 628         GeeCollection* _tmp0_;
 629         self = base;
 630         _tmp0_ = _g_object_ref0 ((GeeCollection*) self);
 631         result = _tmp0_;
 632         return result;
 633 }
 634
 635
 636 GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeIterator* iterator) {
 637         GeeReadOnlyCollectionIterator * self = NULL;
 638         GeeIterator* _tmp0_;
 639         GeeIterator* _tmp1_;
 640         g_return_val_if_fail (iterator != NULL, NULL);
 641         self = (GeeReadOnlyCollectionIterator*) g_object_new (object_type, NULL);
 642         self->priv->g_type = g_type;
 643         self->priv->g_dup_func = g_dup_func;
 644         self->priv->g_destroy_func = g_destroy_func;
 645         _tmp0_ = iterator;
 646         _tmp1_ = _g_object_ref0 (_tmp0_);
 647         _g_object_unref0 (self->_iter);
 648         self->_iter = _tmp1_;
 649         return self;
 650 }
 651
 652
 653 GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeIterator* iterator) {
 654         return gee_read_only_collection_iterator_construct (GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, iterator);
 655 }
 656
 657
 658 static gboolean gee_read_only_collection_iterator_real_next (GeeIterator* base) {
 659         GeeReadOnlyCollectionIterator * self;
 660         gboolean result = FALSE;
 661         GeeIterator* _tmp0_;
 662         gboolean _tmp1_ = FALSE;
 663         self = (GeeReadOnlyCollectionIterator*) base;
 664         _tmp0_ = self->_iter;
 665         _tmp1_ = gee_iterator_next (_tmp0_);
 666         result = _tmp1_;
 667         return result;
 668 }
 669
 670
 671 static gboolean gee_read_only_collection_iterator_real_has_next (GeeIterator* base) {
 672         GeeReadOnlyCollectionIterator * self;
 673         gboolean result = FALSE;
 674         GeeIterator* _tmp0_;
 675         gboolean _tmp1_ = FALSE;
 676         self = (GeeReadOnlyCollectionIterator*) base;
 677         _tmp0_ = self->_iter;
 678         _tmp1_ = gee_iterator_has_next (_tmp0_);
 679         result = _tmp1_;
 680         return result;
 681 }
 682
 683
 684 static gpointer gee_read_only_collection_iterator_real_get (GeeIterator* base) {
 685         GeeReadOnlyCollectionIterator * self;
 686         gpointer result = NULL;
 687         GeeIterator* _tmp0_;
 688         gpointer _tmp1_ = NULL;
 689         self = (GeeReadOnlyCollectionIterator*) base;
 690         _tmp0_ = self->_iter;
 691         _tmp1_ = gee_iterator_get (_tmp0_);
 692         result = _tmp1_;
 693         return result;
 694 }
 695
 696
 697 static void gee_read_only_collection_iterator_real_remove (GeeIterator* base) {
 698         GeeReadOnlyCollectionIterator * self;
 699         self = (GeeReadOnlyCollectionIterator*) base;
 700         g_assert_not_reached ();
 701 }
 702
 703
 704 static gboolean gee_read_only_collection_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
 705         GeeReadOnlyCollectionIterator * self;
 706         gboolean result = FALSE;
 707         GeeIterator* _tmp0_;
 708         GeeForallFunc _tmp1_;
 709         void* _tmp1__target;
 710         gboolean _tmp2_ = FALSE;
 711         self = (GeeReadOnlyCollectionIterator*) base;
 712         _tmp0_ = self->_iter;
 713         _tmp1_ = f;
 714         _tmp1__target = f_target;
 715         _tmp2_ = gee_traversable_foreach ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target);
 716         result = _tmp2_;
 717         return result;
 718 }
 719
 720
 721 static GeeIterator* gee_read_only_collection_iterator_real_stream (GeeTraversable* base, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 722         GeeReadOnlyCollectionIterator * self;
 723         GeeIterator* result = NULL;
 724         GeeIterator* _tmp0_;
 725         GeeStreamFunc _tmp1_;
 726         void* _tmp1__target;
 727         GDestroyNotify _tmp1__target_destroy_notify;
 728         GeeIterator* _tmp2_ = NULL;
 729         self = (GeeReadOnlyCollectionIterator*) base;
 730         _tmp0_ = self->_iter;
 731         _tmp1_ = f;
 732         _tmp1__target = f_target;
 733         _tmp1__target_destroy_notify = f_target_destroy_notify;
 734         f_target_destroy_notify = NULL;
 735         _tmp2_ = gee_traversable_stream ((GeeTraversable*) _tmp0_, a_type, (GBoxedCopyFunc) a_dup_func, a_destroy_func, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
 736         result = _tmp2_;
 737         (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
 738         f = NULL;
 739         f_target = NULL;
 740         f_target_destroy_notify = NULL;
 741         return result;
 742 }
 743
 744
 745 static GeeIterator* gee_read_only_collection_iterator_real_filter (GeeTraversable* base, GeePredicate f, void* f_target, GDestroyNotify f_target_destroy_notify) {
 746         GeeReadOnlyCollectionIterator * self;
 747         GeeIterator* result = NULL;
 748         GeeIterator* _tmp0_;
 749         GeePredicate _tmp1_;
 750         void* _tmp1__target;
 751         GDestroyNotify _tmp1__target_destroy_notify;
 752         GeeIterator* _tmp2_ = NULL;
 753         self = (GeeReadOnlyCollectionIterator*) base;
 754         _tmp0_ = self->_iter;
 755         _tmp1_ = f;
 756         _tmp1__target = f_target;
 757         _tmp1__target_destroy_notify = f_target_destroy_notify;
 758         f_target_destroy_notify = NULL;
 759         _tmp2_ = gee_traversable_filter ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
 760         result = _tmp2_;
 761         (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
 762         f = NULL;
 763         f_target = NULL;
 764         f_target_destroy_notify = NULL;
 765         return result;
 766 }
 767
 768
 769 static GeeIterator* gee_read_only_collection_iterator_real_chop (GeeTraversable* base, gint offset, gint length) {
 770         GeeReadOnlyCollectionIterator * self;
 771         GeeIterator* result = NULL;
 772         GeeIterator* _tmp0_;
 773         gint _tmp1_;
 774         gint _tmp2_;
 775         GeeIterator* _tmp3_ = NULL;
 776         self = (GeeReadOnlyCollectionIterator*) base;
 777         _tmp0_ = self->_iter;
 778         _tmp1_ = offset;
 779         _tmp2_ = length;
 780         _tmp3_ = gee_traversable_chop ((GeeTraversable*) _tmp0_, _tmp1_, _tmp2_);
 781         result = _tmp3_;
 782         return result;
 783 }
 784
 785
 786 static gboolean gee_read_only_collection_iterator_real_get_valid (GeeIterator* base) {
 787         gboolean result;
 788         GeeReadOnlyCollectionIterator* self;
 789         GeeIterator* _tmp0_;
 790         gboolean _tmp1_;
 791         gboolean _tmp2_;
 792         self = (GeeReadOnlyCollectionIterator*) base;
 793         _tmp0_ = self->_iter;
 794         _tmp1_ = gee_iterator_get_valid (_tmp0_);
 795         _tmp2_ = _tmp1_;
 796         result = _tmp2_;
 797         return result;
 798 }
 799
 800
 801 static gboolean gee_read_only_collection_iterator_real_get_read_only (GeeIterator* base) {
 802         gboolean result;
 803         GeeReadOnlyCollectionIterator* self;
 804         self = (GeeReadOnlyCollectionIterator*) base;
 805         result = TRUE;
 806         return result;
 807 }
 808
 809
 810 static GType gee_read_only_collection_iterator_real_get_element_type (GeeTraversable* base) {
 811         GType result;
 812         GeeReadOnlyCollectionIterator* self;
 813         self = (GeeReadOnlyCollectionIterator*) base;
 814         result = self->priv->g_type;
 815         return result;
 816 }
 817
 818
 819 static void gee_read_only_collection_iterator_class_init (GeeReadOnlyCollectionIteratorClass * klass) {
 820         gee_read_only_collection_iterator_parent_class = g_type_class_peek_parent (klass);
 821         g_type_class_add_private (klass, sizeof (GeeReadOnlyCollectionIteratorPrivate));
 822         G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_collection_iterator_get_property;
 823         G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_collection_iterator_set_property;
 824         G_OBJECT_CLASS (klass)->finalize = gee_read_only_collection_iterator_finalize;
 825         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_ITERATOR_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 826         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_ITERATOR_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 827         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_ITERATOR_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 828         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_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));
 829         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_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));
 830 }
 831
 832
 833 static GType gee_read_only_collection_iterator_gee_traversable_get_g_type (GeeReadOnlyCollectionIterator* self) {
 834         return self->priv->g_type;
 835 }
 836
 837
 838 static GBoxedCopyFunc gee_read_only_collection_iterator_gee_traversable_get_g_dup_func (GeeReadOnlyCollectionIterator* self) {
 839         return self->priv->g_dup_func;
 840 }
 841
 842
 843 static GDestroyNotify gee_read_only_collection_iterator_gee_traversable_get_g_destroy_func (GeeReadOnlyCollectionIterator* self) {
 844         return self->priv->g_destroy_func;
 845 }
 846
 847
 848 static void gee_read_only_collection_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
 849         gee_read_only_collection_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
 850         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_read_only_collection_iterator_real_foreach;
 851         iface->stream = (GeeIterator* (*)(GeeTraversable*, GType, GBoxedCopyFunc, GDestroyNotify, GeeStreamFunc, void*, GDestroyNotify)) gee_read_only_collection_iterator_real_stream;
 852         iface->filter = (GeeIterator* (*)(GeeTraversable*, GeePredicate, void*, GDestroyNotify)) gee_read_only_collection_iterator_real_filter;
 853         iface->chop = (GeeIterator* (*)(GeeTraversable*, gint, gint)) gee_read_only_collection_iterator_real_chop;
 854         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_read_only_collection_iterator_gee_traversable_get_g_type;
 855         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_read_only_collection_iterator_gee_traversable_get_g_dup_func;
 856         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_read_only_collection_iterator_gee_traversable_get_g_destroy_func;
 857         iface->get_element_type = gee_read_only_collection_iterator_real_get_element_type;
 858 }
 859
 860
 861 static void gee_read_only_collection_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
 862         gee_read_only_collection_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
 863         iface->next = (gboolean (*)(GeeIterator*)) gee_read_only_collection_iterator_real_next;
 864         iface->has_next = (gboolean (*)(GeeIterator*)) gee_read_only_collection_iterator_real_has_next;
 865         iface->get = (gpointer (*)(GeeIterator*)) gee_read_only_collection_iterator_real_get;
 866         iface->remove = (void (*)(GeeIterator*)) gee_read_only_collection_iterator_real_remove;
 867         iface->get_valid = gee_read_only_collection_iterator_real_get_valid;
 868         iface->get_read_only = gee_read_only_collection_iterator_real_get_read_only;
 869 }
 870
 871
 872 static void gee_read_only_collection_iterator_instance_init (GeeReadOnlyCollectionIterator * self) {
 873         self->priv = GEE_READ_ONLY_COLLECTION_ITERATOR_GET_PRIVATE (self);
 874 }
 875
 876
 877 static void gee_read_only_collection_iterator_finalize (GObject* obj) {
 878         GeeReadOnlyCollectionIterator * self;
 879         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator);
 880         _g_object_unref0 (self->_iter);
 881         G_OBJECT_CLASS (gee_read_only_collection_iterator_parent_class)->finalize (obj);
 882 }
 883
 884
 885 GType gee_read_only_collection_iterator_get_type (void) {
 886         static volatile gsize gee_read_only_collection_iterator_type_id__volatile = 0;
 887         if (g_once_init_enter (&gee_read_only_collection_iterator_type_id__volatile)) {
 888                 static const GTypeInfo g_define_type_info = { sizeof (GeeReadOnlyCollectionIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_read_only_collection_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeReadOnlyCollectionIterator), 0, (GInstanceInitFunc) gee_read_only_collection_iterator_instance_init, NULL };
 889                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_read_only_collection_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 890                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_read_only_collection_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 891                 GType gee_read_only_collection_iterator_type_id;
 892                 gee_read_only_collection_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeReadOnlyCollectionIterator", &g_define_type_info, 0);
 893                 g_type_add_interface_static (gee_read_only_collection_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
 894                 g_type_add_interface_static (gee_read_only_collection_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
 895                 g_once_init_leave (&gee_read_only_collection_iterator_type_id__volatile, gee_read_only_collection_iterator_type_id);
 896         }
 897         return gee_read_only_collection_iterator_type_id__volatile;
 898 }
 899
 900
 901 static void _vala_gee_read_only_collection_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 902         GeeReadOnlyCollectionIterator * self;
 903         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator);
 904         switch (property_id) {
 905                 case GEE_READ_ONLY_COLLECTION_ITERATOR_VALID:
 906                 g_value_set_boolean (value, gee_iterator_get_valid ((GeeIterator*) self));
 907                 break;
 908                 case GEE_READ_ONLY_COLLECTION_ITERATOR_READ_ONLY:
 909                 g_value_set_boolean (value, gee_iterator_get_read_only ((GeeIterator*) self));
 910                 break;
 911                 default:
 912                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 913                 break;
 914         }
 915 }
 916
 917
 918 static void _vala_gee_read_only_collection_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 919         GeeReadOnlyCollectionIterator * self;
 920         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator);
 921         switch (property_id) {
 922                 case GEE_READ_ONLY_COLLECTION_ITERATOR_G_TYPE:
 923                 self->priv->g_type = g_value_get_gtype (value);
 924                 break;
 925                 case GEE_READ_ONLY_COLLECTION_ITERATOR_G_DUP_FUNC:
 926                 self->priv->g_dup_func = g_value_get_pointer (value);
 927                 break;
 928                 case GEE_READ_ONLY_COLLECTION_ITERATOR_G_DESTROY_FUNC:
 929                 self->priv->g_destroy_func = g_value_get_pointer (value);
 930                 break;
 931                 default:
 932                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 933                 break;
 934         }
 935 }
 936
 937
 938 static void gee_read_only_collection_class_init (GeeReadOnlyCollectionClass * klass) {
 939         gee_read_only_collection_parent_class = g_type_class_peek_parent (klass);
 940         g_type_class_add_private (klass, sizeof (GeeReadOnlyCollectionPrivate));
 941         GEE_READ_ONLY_COLLECTION_CLASS (klass)->get_read_only_view = gee_read_only_collection_real_get_read_only_view;
 942         G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_collection_get_property;
 943         G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_collection_set_property;
 944         G_OBJECT_CLASS (klass)->finalize = gee_read_only_collection_finalize;
 945         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 946         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 947         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 948         /**
 949          * {@inheritDoc}
 950          */
 951         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_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));
 952         /**
 953          * {@inheritDoc}
 954          */
 955         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_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));
 956         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_READ_ONLY_VIEW, g_param_spec_object ("read-only-view", "read-only-view", "read-only-view", GEE_TYPE_COLLECTION, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 957 }
 958
 959
 960 static GType gee_read_only_collection_gee_traversable_get_g_type (GeeReadOnlyCollection* self) {
 961         return self->priv->g_type;
 962 }
 963
 964
 965 static GBoxedCopyFunc gee_read_only_collection_gee_traversable_get_g_dup_func (GeeReadOnlyCollection* self) {
 966         return self->priv->g_dup_func;
 967 }
 968
 969
 970 static GDestroyNotify gee_read_only_collection_gee_traversable_get_g_destroy_func (GeeReadOnlyCollection* self) {
 971         return self->priv->g_destroy_func;
 972 }
 973
 974
 975 static void gee_read_only_collection_gee_traversable_interface_init (GeeTraversableIface * iface) {
 976         gee_read_only_collection_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
 977         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_read_only_collection_real_foreach;
 978         iface->stream = (GeeIterator* (*)(GeeTraversable*, GType, GBoxedCopyFunc, GDestroyNotify, GeeStreamFunc, void*, GDestroyNotify)) gee_read_only_collection_real_stream;
 979         iface->filter = (GeeIterator* (*)(GeeTraversable*, GeePredicate, void*, GDestroyNotify)) gee_read_only_collection_real_filter;
 980         iface->chop = (GeeIterator* (*)(GeeTraversable*, gint, gint)) gee_read_only_collection_real_chop;
 981         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_read_only_collection_gee_traversable_get_g_type;
 982         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_read_only_collection_gee_traversable_get_g_dup_func;
 983         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_read_only_collection_gee_traversable_get_g_destroy_func;
 984         iface->get_element_type = gee_read_only_collection_real_get_element_type;
 985 }
 986
 987
 988 static GType gee_read_only_collection_gee_iterable_get_g_type (GeeReadOnlyCollection* self) {
 989         return self->priv->g_type;
 990 }
 991
 992
 993 static GBoxedCopyFunc gee_read_only_collection_gee_iterable_get_g_dup_func (GeeReadOnlyCollection* self) {
 994         return self->priv->g_dup_func;
 995 }
 996
 997
 998 static GDestroyNotify gee_read_only_collection_gee_iterable_get_g_destroy_func (GeeReadOnlyCollection* self) {
 999         return self->priv->g_destroy_func;
1000 }
1001
1002
1003 static void gee_read_only_collection_gee_iterable_interface_init (GeeIterableIface * iface) {
1004         gee_read_only_collection_gee_iterable_parent_iface = g_type_interface_peek_parent (iface);
1005         iface->iterator = (GeeIterator* (*)(GeeIterable*)) gee_read_only_collection_real_iterator;
1006         iface->get_g_type = (GType(*)(GeeIterable*)) gee_read_only_collection_gee_iterable_get_g_type;
1007         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeIterable*)) gee_read_only_collection_gee_iterable_get_g_dup_func;
1008         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeIterable*)) gee_read_only_collection_gee_iterable_get_g_destroy_func;
1009 }
1010
1011
1012 static GType gee_read_only_collection_gee_collection_get_g_type (GeeReadOnlyCollection* self) {
1013         return self->priv->g_type;
1014 }
1015
1016
1017 static GBoxedCopyFunc gee_read_only_collection_gee_collection_get_g_dup_func (GeeReadOnlyCollection* self) {
1018         return self->priv->g_dup_func;
1019 }
1020
1021
1022 static GDestroyNotify gee_read_only_collection_gee_collection_get_g_destroy_func (GeeReadOnlyCollection* self) {
1023         return self->priv->g_destroy_func;
1024 }
1025
1026
1027 static void gee_read_only_collection_gee_collection_interface_init (GeeCollectionIface * iface) {
1028         gee_read_only_collection_gee_collection_parent_iface = g_type_interface_peek_parent (iface);
1029         iface->contains = (gboolean (*)(GeeCollection*, gconstpointer)) gee_read_only_collection_real_contains;
1030         iface->add = (gboolean (*)(GeeCollection*, gconstpointer)) gee_read_only_collection_real_add;
1031         iface->remove = (gboolean (*)(GeeCollection*, gconstpointer)) gee_read_only_collection_real_remove;
1032         iface->clear = (void (*)(GeeCollection*)) gee_read_only_collection_real_clear;
1033         iface->add_all = (gboolean (*)(GeeCollection*, GeeCollection*)) gee_read_only_collection_real_add_all;
1034         iface->contains_all = (gboolean (*)(GeeCollection*, GeeCollection*)) gee_read_only_collection_real_contains_all;
1035         iface->remove_all = (gboolean (*)(GeeCollection*, GeeCollection*)) gee_read_only_collection_real_remove_all;
1036         iface->retain_all = (gboolean (*)(GeeCollection*, GeeCollection*)) gee_read_only_collection_real_retain_all;
1037         iface->to_array = (gpointer* (*)(GeeCollection*, int*)) gee_read_only_collection_real_to_array;
1038         iface->get_g_type = (GType(*)(GeeCollection*)) gee_read_only_collection_gee_collection_get_g_type;
1039         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeCollection*)) gee_read_only_collection_gee_collection_get_g_dup_func;
1040         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeCollection*)) gee_read_only_collection_gee_collection_get_g_destroy_func;
1041         iface->get_size = gee_read_only_collection_real_get_size;
1042         iface->get_is_empty = gee_read_only_collection_real_get_is_empty;
1043         iface->get_read_only = gee_read_only_collection_real_get_read_only;
1044         iface->get_read_only_view = (GeeCollection* (*) (GeeCollection *)) gee_read_only_collection_get_read_only_view;
1045 }
1046
1047
1048 static void gee_read_only_collection_instance_init (GeeReadOnlyCollection * self) {
1049         self->priv = GEE_READ_ONLY_COLLECTION_GET_PRIVATE (self);
1050 }
1051
1052
1053 static void gee_read_only_collection_finalize (GObject* obj) {
1054         GeeReadOnlyCollection * self;
1055         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection);
1056         _g_object_unref0 (self->_collection);
1057         G_OBJECT_CLASS (gee_read_only_collection_parent_class)->finalize (obj);
1058 }
1059
1060
1061 /**
1062  * Read-only view for {@link Collection} collections.
1063  *
1064  * This class decorates any class which implements the {@link Collection}
1065  * interface by making it read only. Any method which normally modify data will
1066  * throw an error.
1067  *
1068  * @see Collection
1069  */
1070 GType gee_read_only_collection_get_type (void) {
1071         static volatile gsize gee_read_only_collection_type_id__volatile = 0;
1072         if (g_once_init_enter (&gee_read_only_collection_type_id__volatile)) {
1073                 static const GTypeInfo g_define_type_info = { sizeof (GeeReadOnlyCollectionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_read_only_collection_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeReadOnlyCollection), 0, (GInstanceInitFunc) gee_read_only_collection_instance_init, NULL };
1074                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_read_only_collection_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1075                 static const GInterfaceInfo gee_iterable_info = { (GInterfaceInitFunc) gee_read_only_collection_gee_iterable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1076                 static const GInterfaceInfo gee_collection_info = { (GInterfaceInitFunc) gee_read_only_collection_gee_collection_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1077                 GType gee_read_only_collection_type_id;
1078                 gee_read_only_collection_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeReadOnlyCollection", &g_define_type_info, 0);
1079                 g_type_add_interface_static (gee_read_only_collection_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
1080                 g_type_add_interface_static (gee_read_only_collection_type_id, GEE_TYPE_ITERABLE, &gee_iterable_info);
1081                 g_type_add_interface_static (gee_read_only_collection_type_id, GEE_TYPE_COLLECTION, &gee_collection_info);
1082                 g_once_init_leave (&gee_read_only_collection_type_id__volatile, gee_read_only_collection_type_id);
1083         }
1084         return gee_read_only_collection_type_id__volatile;
1085 }
1086
1087
1088 static void _vala_gee_read_only_collection_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
1089         GeeReadOnlyCollection * self;
1090         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection);
1091         switch (property_id) {
1092                 case GEE_READ_ONLY_COLLECTION_SIZE:
1093                 g_value_set_int (value, gee_collection_get_size ((GeeCollection*) self));
1094                 break;
1095                 case GEE_READ_ONLY_COLLECTION_READ_ONLY:
1096                 g_value_set_boolean (value, gee_collection_get_read_only ((GeeCollection*) self));
1097                 break;
1098                 case GEE_READ_ONLY_COLLECTION_READ_ONLY_VIEW:
1099                 g_value_take_object (value, gee_read_only_collection_get_read_only_view (self));
1100                 break;
1101                 default:
1102                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1103                 break;
1104         }
1105 }
1106
1107
1108 static void _vala_gee_read_only_collection_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
1109         GeeReadOnlyCollection * self;
1110         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection);
1111         switch (property_id) {
1112                 case GEE_READ_ONLY_COLLECTION_G_TYPE:
1113                 self->priv->g_type = g_value_get_gtype (value);
1114                 break;
1115                 case GEE_READ_ONLY_COLLECTION_G_DUP_FUNC:
1116                 self->priv->g_dup_func = g_value_get_pointer (value);
1117                 break;
1118                 case GEE_READ_ONLY_COLLECTION_G_DESTROY_FUNC:
1119                 self->priv->g_destroy_func = g_value_get_pointer (value);
1120                 break;
1121                 default:
1122                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1123                 break;
1124         }
1125 }
1126
1127
1128