gee/readonlylist.c

   1 /* readonlylist.c generated by valac 0.18.0, the Vala compiler
   2  * generated from readonlylist.vala, do not modify */
   3
   4 /* readonlylist.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_ITERABLE (gee_iterable_get_type ())
  31 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  32 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  33 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  34
  35 typedef struct _GeeIterable GeeIterable;
  36 typedef struct _GeeIterableIface GeeIterableIface;
  37
  38 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  39 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  40 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  41 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  42
  43 typedef struct _GeeIterator GeeIterator;
  44 typedef struct _GeeIteratorIface GeeIteratorIface;
  45
  46 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  47 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  48 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  49 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  50
  51 typedef struct _GeeCollection GeeCollection;
  52 typedef struct _GeeCollectionIface GeeCollectionIface;
  53
  54 #define GEE_TYPE_READ_ONLY_COLLECTION (gee_read_only_collection_get_type ())
  55 #define GEE_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection))
  56 #define GEE_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
  57 #define GEE_IS_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_COLLECTION))
  58 #define GEE_IS_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_COLLECTION))
  59 #define GEE_READ_ONLY_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
  60
  61 typedef struct _GeeReadOnlyCollection GeeReadOnlyCollection;
  62 typedef struct _GeeReadOnlyCollectionClass GeeReadOnlyCollectionClass;
  63 typedef struct _GeeReadOnlyCollectionPrivate GeeReadOnlyCollectionPrivate;
  64
  65 #define GEE_TYPE_LIST (gee_list_get_type ())
  66 #define GEE_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LIST, GeeList))
  67 #define GEE_IS_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LIST))
  68 #define GEE_LIST_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_LIST, GeeListIface))
  69
  70 typedef struct _GeeList GeeList;
  71 typedef struct _GeeListIface GeeListIface;
  72
  73 #define GEE_TYPE_BIDIR_ITERATOR (gee_bidir_iterator_get_type ())
  74 #define GEE_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIterator))
  75 #define GEE_IS_BIDIR_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_BIDIR_ITERATOR))
  76 #define GEE_BIDIR_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_BIDIR_ITERATOR, GeeBidirIteratorIface))
  77
  78 typedef struct _GeeBidirIterator GeeBidirIterator;
  79 typedef struct _GeeBidirIteratorIface GeeBidirIteratorIface;
  80
  81 #define GEE_TYPE_LIST_ITERATOR (gee_list_iterator_get_type ())
  82 #define GEE_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LIST_ITERATOR, GeeListIterator))
  83 #define GEE_IS_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LIST_ITERATOR))
  84 #define GEE_LIST_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_LIST_ITERATOR, GeeListIteratorIface))
  85
  86 typedef struct _GeeListIterator GeeListIterator;
  87 typedef struct _GeeListIteratorIface GeeListIteratorIface;
  88
  89 #define GEE_TYPE_READ_ONLY_LIST (gee_read_only_list_get_type ())
  90 #define GEE_READ_ONLY_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_LIST, GeeReadOnlyList))
  91 #define GEE_READ_ONLY_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_LIST, GeeReadOnlyListClass))
  92 #define GEE_IS_READ_ONLY_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_LIST))
  93 #define GEE_IS_READ_ONLY_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_LIST))
  94 #define GEE_READ_ONLY_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_LIST, GeeReadOnlyListClass))
  95
  96 typedef struct _GeeReadOnlyList GeeReadOnlyList;
  97 typedef struct _GeeReadOnlyListClass GeeReadOnlyListClass;
  98 typedef struct _GeeReadOnlyListPrivate GeeReadOnlyListPrivate;
  99
 100 #define GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR (gee_read_only_collection_iterator_get_type ())
 101 #define GEE_READ_ONLY_COLLECTION_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator))
 102 #define GEE_READ_ONLY_COLLECTION_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIteratorClass))
 103 #define GEE_READ_ONLY_COLLECTION_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR))
 104 #define GEE_READ_ONLY_COLLECTION_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR))
 105 #define GEE_READ_ONLY_COLLECTION_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIteratorClass))
 106
 107 typedef struct _GeeReadOnlyCollectionIterator GeeReadOnlyCollectionIterator;
 108 typedef struct _GeeReadOnlyCollectionIteratorClass GeeReadOnlyCollectionIteratorClass;
 109
 110 #define GEE_READ_ONLY_LIST_TYPE_ITERATOR (gee_read_only_list_iterator_get_type ())
 111 #define GEE_READ_ONLY_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_READ_ONLY_LIST_TYPE_ITERATOR, GeeReadOnlyListIterator))
 112 #define GEE_READ_ONLY_LIST_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_READ_ONLY_LIST_TYPE_ITERATOR, GeeReadOnlyListIteratorClass))
 113 #define GEE_READ_ONLY_LIST_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_READ_ONLY_LIST_TYPE_ITERATOR))
 114 #define GEE_READ_ONLY_LIST_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_READ_ONLY_LIST_TYPE_ITERATOR))
 115 #define GEE_READ_ONLY_LIST_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_READ_ONLY_LIST_TYPE_ITERATOR, GeeReadOnlyListIteratorClass))
 116
 117 typedef struct _GeeReadOnlyListIterator GeeReadOnlyListIterator;
 118 typedef struct _GeeReadOnlyListIteratorClass GeeReadOnlyListIteratorClass;
 119 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 120 typedef struct _GeeReadOnlyCollectionIteratorPrivate GeeReadOnlyCollectionIteratorPrivate;
 121 typedef struct _GeeReadOnlyListIteratorPrivate GeeReadOnlyListIteratorPrivate;
 122
 123 struct _GeeIteratorIface {
 124         GTypeInterface parent_iface;
 125         gboolean (*next) (GeeIterator* self);
 126         gboolean (*has_next) (GeeIterator* self);
 127         gboolean (*first) (GeeIterator* self);
 128         gpointer (*get) (GeeIterator* self);
 129         void (*remove) (GeeIterator* self);
 130 };
 131
 132 struct _GeeIterableIface {
 133         GTypeInterface parent_iface;
 134         GeeIterator* (*iterator) (GeeIterable* self);
 135         GType (*get_element_type) (GeeIterable* self);
 136 };
 137
 138 struct _GeeCollectionIface {
 139         GTypeInterface parent_iface;
 140         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 141         gboolean (*add) (GeeCollection* self, gconstpointer item);
 142         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 143         void (*clear) (GeeCollection* self);
 144         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 145         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 146         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 147         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 148         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 149         gint (*get_size) (GeeCollection* self);
 150         gboolean (*get_is_empty) (GeeCollection* self);
 151         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 152 };
 153
 154 struct _GeeReadOnlyCollection {
 155         GObject parent_instance;
 156         GeeReadOnlyCollectionPrivate * priv;
 157         GeeCollection* _collection;
 158 };
 159
 160 struct _GeeReadOnlyCollectionClass {
 161         GObjectClass parent_class;
 162         GeeCollection* (*get_read_only_view) (GeeReadOnlyCollection* self);
 163 };
 164
 165 struct _GeeBidirIteratorIface {
 166         GTypeInterface parent_iface;
 167         gboolean (*previous) (GeeBidirIterator* self);
 168         gboolean (*has_previous) (GeeBidirIterator* self);
 169         gboolean (*last) (GeeBidirIterator* self);
 170 };
 171
 172 struct _GeeListIteratorIface {
 173         GTypeInterface parent_iface;
 174         void (*set) (GeeListIterator* self, gconstpointer item);
 175         void (*insert) (GeeListIterator* self, gconstpointer item);
 176         void (*add) (GeeListIterator* self, gconstpointer item);
 177         gint (*index) (GeeListIterator* self);
 178 };
 179
 180 struct _GeeListIface {
 181         GTypeInterface parent_iface;
 182         GeeListIterator* (*list_iterator) (GeeList* self);
 183         gpointer (*get) (GeeList* self, gint index);
 184         void (*set) (GeeList* self, gint index, gconstpointer item);
 185         gint (*index_of) (GeeList* self, gconstpointer item);
 186         void (*insert) (GeeList* self, gint index, gconstpointer item);
 187         gpointer (*remove_at) (GeeList* self, gint index);
 188         GeeList* (*slice) (GeeList* self, gint start, gint stop);
 189         gpointer (*first) (GeeList* self);
 190         gpointer (*last) (GeeList* self);
 191         void (*insert_all) (GeeList* self, gint index, GeeCollection* collection);
 192         void (*sort) (GeeList* self, GCompareFunc compare_func);
 193         GeeList* (*get_read_only_view) (GeeList* self);
 194 };
 195
 196 struct _GeeReadOnlyList {
 197         GeeReadOnlyCollection parent_instance;
 198         GeeReadOnlyListPrivate * priv;
 199 };
 200
 201 struct _GeeReadOnlyListClass {
 202         GeeReadOnlyCollectionClass parent_class;
 203         GeeList* (*get_read_only_view) (GeeReadOnlyList* self);
 204 };
 205
 206 struct _GeeReadOnlyListPrivate {
 207         GType g_type;
 208         GBoxedCopyFunc g_dup_func;
 209         GDestroyNotify g_destroy_func;
 210 };
 211
 212 struct _GeeReadOnlyCollectionIterator {
 213         GObject parent_instance;
 214         GeeReadOnlyCollectionIteratorPrivate * priv;
 215         GeeIterator* _iter;
 216 };
 217
 218 struct _GeeReadOnlyCollectionIteratorClass {
 219         GObjectClass parent_class;
 220 };
 221
 222 struct _GeeReadOnlyListIterator {
 223         GeeReadOnlyCollectionIterator parent_instance;
 224         GeeReadOnlyListIteratorPrivate * priv;
 225 };
 226
 227 struct _GeeReadOnlyListIteratorClass {
 228         GeeReadOnlyCollectionIteratorClass parent_class;
 229 };
 230
 231 struct _GeeReadOnlyListIteratorPrivate {
 232         GType g_type;
 233         GBoxedCopyFunc g_dup_func;
 234         GDestroyNotify g_destroy_func;
 235 };
 236
 237
 238 static gpointer gee_read_only_list_parent_class = NULL;
 239 static gpointer gee_read_only_list_iterator_parent_class = NULL;
 240 static GeeBidirIteratorIface* gee_read_only_list_iterator_gee_bidir_iterator_parent_iface = NULL;
 241 static GeeListIteratorIface* gee_read_only_list_iterator_gee_list_iterator_parent_iface = NULL;
 242 static GeeListIface* gee_read_only_list_gee_list_parent_iface = NULL;
 243
 244 GType gee_iterator_get_type (void) G_GNUC_CONST;
 245 GType gee_iterable_get_type (void) G_GNUC_CONST;
 246 GType gee_collection_get_type (void) G_GNUC_CONST;
 247 GType gee_read_only_collection_get_type (void) G_GNUC_CONST;
 248 GType gee_bidir_iterator_get_type (void) G_GNUC_CONST;
 249 GType gee_list_iterator_get_type (void) G_GNUC_CONST;
 250 GType gee_list_get_type (void) G_GNUC_CONST;
 251 GType gee_read_only_list_get_type (void) G_GNUC_CONST;
 252 #define GEE_READ_ONLY_LIST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_READ_ONLY_LIST, GeeReadOnlyListPrivate))
 253 enum  {
 254         GEE_READ_ONLY_LIST_DUMMY_PROPERTY,
 255         GEE_READ_ONLY_LIST_G_TYPE,
 256         GEE_READ_ONLY_LIST_G_DUP_FUNC,
 257         GEE_READ_ONLY_LIST_G_DESTROY_FUNC,
 258         GEE_READ_ONLY_LIST_READ_ONLY_VIEW
 259 };
 260 GeeReadOnlyList* gee_read_only_list_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeList* list);
 261 GeeReadOnlyList* gee_read_only_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeList* list);
 262 GeeReadOnlyCollection* gee_read_only_collection_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeCollection* collection);
 263 GeeReadOnlyCollection* gee_read_only_collection_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeCollection* collection);
 264 static GeeListIterator* gee_read_only_list_real_list_iterator (GeeList* base);
 265 GeeListIterator* gee_list_list_iterator (GeeList* self);
 266 static GeeReadOnlyListIterator* gee_read_only_list_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeListIterator* iterator);
 267 static GeeReadOnlyListIterator* gee_read_only_list_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeListIterator* iterator);
 268 GType gee_read_only_collection_iterator_get_type (void) G_GNUC_CONST;
 269 static GType gee_read_only_list_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 270 static gint gee_read_only_list_real_index_of (GeeList* base, gconstpointer item);
 271 gint gee_list_index_of (GeeList* self, gconstpointer item);
 272 static void gee_read_only_list_real_insert (GeeList* base, gint index, gconstpointer item);
 273 static gpointer gee_read_only_list_real_remove_at (GeeList* base, gint index);
 274 static gpointer gee_read_only_list_real_get (GeeList* base, gint index);
 275 gpointer gee_list_get (GeeList* self, gint index);
 276 static void gee_read_only_list_real_set (GeeList* base, gint index, gconstpointer o);
 277 static GeeList* gee_read_only_list_real_slice (GeeList* base, gint start, gint stop);
 278 static gpointer gee_read_only_list_real_first (GeeList* base);
 279 gpointer gee_list_first (GeeList* self);
 280 static gpointer gee_read_only_list_real_last (GeeList* base);
 281 gpointer gee_list_last (GeeList* self);
 282 static void gee_read_only_list_real_insert_all (GeeList* base, gint index, GeeCollection* collection);
 283 static void gee_read_only_list_real_sort (GeeList* base, GCompareFunc compare);
 284 GeeList* gee_read_only_list_get_read_only_view (GeeReadOnlyList* self);
 285 #define GEE_READ_ONLY_LIST_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_READ_ONLY_LIST_TYPE_ITERATOR, GeeReadOnlyListIteratorPrivate))
 286 enum  {
 287         GEE_READ_ONLY_LIST_ITERATOR_DUMMY_PROPERTY,
 288         GEE_READ_ONLY_LIST_ITERATOR_G_TYPE,
 289         GEE_READ_ONLY_LIST_ITERATOR_G_DUP_FUNC,
 290         GEE_READ_ONLY_LIST_ITERATOR_G_DESTROY_FUNC
 291 };
 292 GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeIterator* iterator);
 293 GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeIterator* iterator);
 294 static gboolean gee_read_only_list_iterator_real_previous (GeeBidirIterator* base);
 295 gboolean gee_bidir_iterator_previous (GeeBidirIterator* self);
 296 static gboolean gee_read_only_list_iterator_real_has_previous (GeeBidirIterator* base);
 297 gboolean gee_bidir_iterator_has_previous (GeeBidirIterator* self);
 298 static gboolean gee_read_only_list_iterator_real_last (GeeBidirIterator* base);
 299 gboolean gee_bidir_iterator_last (GeeBidirIterator* self);
 300 static void gee_read_only_list_iterator_real_set (GeeListIterator* base, gconstpointer item);
 301 static void gee_read_only_list_iterator_real_insert (GeeListIterator* base, gconstpointer item);
 302 static void gee_read_only_list_iterator_real_add (GeeListIterator* base, gconstpointer item);
 303 static gint gee_read_only_list_iterator_real_index (GeeListIterator* base);
 304 gint gee_list_iterator_index (GeeListIterator* self);
 305 static void _vala_gee_read_only_list_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 306 static void _vala_gee_read_only_list_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 307 static void _vala_gee_read_only_list_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 308 static void _vala_gee_read_only_list_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 309
 310
 311 /**
 312  * Constructs a read-only list that mirrors the content of the specified
 313  * list.
 314  *
 315  * @param list the list to decorate.
 316  */
 317 GeeReadOnlyList* gee_read_only_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeList* list) {
 318         GeeReadOnlyList * self = NULL;
 319         GeeList* _tmp0_;
 320         g_return_val_if_fail (list != NULL, NULL);
 321         _tmp0_ = list;
 322         self = (GeeReadOnlyList*) gee_read_only_collection_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, (GeeCollection*) _tmp0_);
 323         self->priv->g_type = g_type;
 324         self->priv->g_dup_func = g_dup_func;
 325         self->priv->g_destroy_func = g_destroy_func;
 326         return self;
 327 }
 328
 329
 330 GeeReadOnlyList* gee_read_only_list_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeList* list) {
 331         return gee_read_only_list_construct (GEE_TYPE_READ_ONLY_LIST, g_type, g_dup_func, g_destroy_func, list);
 332 }
 333
 334
 335 /**
 336  * {@inheritDoc}
 337  */
 338 static GeeListIterator* gee_read_only_list_real_list_iterator (GeeList* base) {
 339         GeeReadOnlyList * self;
 340         GeeListIterator* result = NULL;
 341         GeeCollection* _tmp0_;
 342         GeeListIterator* _tmp1_ = NULL;
 343         GeeListIterator* _tmp2_;
 344         GeeReadOnlyListIterator* _tmp3_;
 345         GeeListIterator* _tmp4_;
 346         self = (GeeReadOnlyList*) base;
 347         _tmp0_ = ((GeeReadOnlyCollection*) self)->_collection;
 348         _tmp1_ = gee_list_list_iterator (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST, GeeList));
 349         _tmp2_ = _tmp1_;
 350         _tmp3_ = gee_read_only_list_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp2_);
 351         _tmp4_ = (GeeListIterator*) _tmp3_;
 352         _g_object_unref0 (_tmp2_);
 353         result = _tmp4_;
 354         return result;
 355 }
 356
 357
 358 /**
 359  * {@inheritDoc}
 360  */
 361 static gint gee_read_only_list_real_index_of (GeeList* base, gconstpointer item) {
 362         GeeReadOnlyList * self;
 363         gint result = 0;
 364         GeeCollection* _tmp0_;
 365         gconstpointer _tmp1_;
 366         gint _tmp2_ = 0;
 367         self = (GeeReadOnlyList*) base;
 368         _tmp0_ = ((GeeReadOnlyCollection*) self)->_collection;
 369         _tmp1_ = item;
 370         _tmp2_ = gee_list_index_of (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST, GeeList), _tmp1_);
 371         result = _tmp2_;
 372         return result;
 373 }
 374
 375
 376 /**
 377  * Unimplemented method (read only list).
 378  */
 379 static void gee_read_only_list_real_insert (GeeList* base, gint index, gconstpointer item) {
 380         GeeReadOnlyList * self;
 381         self = (GeeReadOnlyList*) base;
 382         g_assert_not_reached ();
 383 }
 384
 385
 386 /**
 387  * Unimplemented method (read only list).
 388  */
 389 static gpointer gee_read_only_list_real_remove_at (GeeList* base, gint index) {
 390         GeeReadOnlyList * self;
 391         gpointer result = NULL;
 392         self = (GeeReadOnlyList*) base;
 393         g_assert_not_reached ();
 394         return result;
 395 }
 396
 397
 398 /**
 399  * {@inheritDoc}
 400  */
 401 static gpointer gee_read_only_list_real_get (GeeList* base, gint index) {
 402         GeeReadOnlyList * self;
 403         gpointer result = NULL;
 404         GeeCollection* _tmp0_;
 405         gint _tmp1_;
 406         gpointer _tmp2_ = NULL;
 407         self = (GeeReadOnlyList*) base;
 408         _tmp0_ = ((GeeReadOnlyCollection*) self)->_collection;
 409         _tmp1_ = index;
 410         _tmp2_ = gee_list_get (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST, GeeList), _tmp1_);
 411         result = _tmp2_;
 412         return result;
 413 }
 414
 415
 416 /**
 417  * Unimplemented method (read only list).
 418  */
 419 static void gee_read_only_list_real_set (GeeList* base, gint index, gconstpointer o) {
 420         GeeReadOnlyList * self;
 421         self = (GeeReadOnlyList*) base;
 422         g_assert_not_reached ();
 423 }
 424
 425
 426 /**
 427  * Unimplemented method (read only list).
 428  */
 429 static GeeList* gee_read_only_list_real_slice (GeeList* base, gint start, gint stop) {
 430         GeeReadOnlyList * self;
 431         GeeList* result = NULL;
 432         self = (GeeReadOnlyList*) base;
 433         g_assert_not_reached ();
 434         return result;
 435 }
 436
 437
 438 /**
 439  * {@inheritDoc}
 440  */
 441 static gpointer gee_read_only_list_real_first (GeeList* base) {
 442         GeeReadOnlyList * self;
 443         gpointer result = NULL;
 444         GeeCollection* _tmp0_;
 445         gpointer _tmp1_ = NULL;
 446         self = (GeeReadOnlyList*) base;
 447         _tmp0_ = ((GeeReadOnlyCollection*) self)->_collection;
 448         _tmp1_ = gee_list_first (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST, GeeList));
 449         result = _tmp1_;
 450         return result;
 451 }
 452
 453
 454 /**
 455  * {@inheritDoc}
 456  */
 457 static gpointer gee_read_only_list_real_last (GeeList* base) {
 458         GeeReadOnlyList * self;
 459         gpointer result = NULL;
 460         GeeCollection* _tmp0_;
 461         gpointer _tmp1_ = NULL;
 462         self = (GeeReadOnlyList*) base;
 463         _tmp0_ = ((GeeReadOnlyCollection*) self)->_collection;
 464         _tmp1_ = gee_list_last (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST, GeeList));
 465         result = _tmp1_;
 466         return result;
 467 }
 468
 469
 470 /**
 471  * Unimplemented method (read only list).
 472  */
 473 static void gee_read_only_list_real_insert_all (GeeList* base, gint index, GeeCollection* collection) {
 474         GeeReadOnlyList * self;
 475         self = (GeeReadOnlyList*) base;
 476         g_return_if_fail (collection != NULL);
 477         g_assert_not_reached ();
 478 }
 479
 480
 481 /**
 482  * {@inheritDoc}
 483  */
 484 static void gee_read_only_list_real_sort (GeeList* base, GCompareFunc compare) {
 485         GeeReadOnlyList * self;
 486         self = (GeeReadOnlyList*) base;
 487         g_assert_not_reached ();
 488 }
 489
 490
 491 GeeList* gee_read_only_list_get_read_only_view (GeeReadOnlyList* self) {
 492         g_return_val_if_fail (self != NULL, NULL);
 493         return GEE_READ_ONLY_LIST_GET_CLASS (self)->get_read_only_view (self);
 494 }
 495
 496
 497 static gpointer _g_object_ref0 (gpointer self) {
 498         return self ? g_object_ref (self) : NULL;
 499 }
 500
 501
 502 static GeeList* gee_read_only_list_real_get_read_only_view (GeeReadOnlyList* base) {
 503         GeeList* result;
 504         GeeReadOnlyList* self;
 505         GeeList* _tmp0_;
 506         self = base;
 507         _tmp0_ = _g_object_ref0 ((GeeList*) self);
 508         result = _tmp0_;
 509         return result;
 510 }
 511
 512
 513 static GeeReadOnlyListIterator* gee_read_only_list_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeListIterator* iterator) {
 514         GeeReadOnlyListIterator * self = NULL;
 515         GeeListIterator* _tmp0_;
 516         g_return_val_if_fail (iterator != NULL, NULL);
 517         _tmp0_ = iterator;
 518         self = (GeeReadOnlyListIterator*) gee_read_only_collection_iterator_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, (GeeIterator*) _tmp0_);
 519         self->priv->g_type = g_type;
 520         self->priv->g_dup_func = g_dup_func;
 521         self->priv->g_destroy_func = g_destroy_func;
 522         return self;
 523 }
 524
 525
 526 static GeeReadOnlyListIterator* gee_read_only_list_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeListIterator* iterator) {
 527         return gee_read_only_list_iterator_construct (GEE_READ_ONLY_LIST_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, iterator);
 528 }
 529
 530
 531 static gboolean gee_read_only_list_iterator_real_previous (GeeBidirIterator* base) {
 532         GeeReadOnlyListIterator * self;
 533         gboolean result = FALSE;
 534         GeeIterator* _tmp0_;
 535         gboolean _tmp1_ = FALSE;
 536         self = (GeeReadOnlyListIterator*) base;
 537         _tmp0_ = ((GeeReadOnlyCollectionIterator*) self)->_iter;
 538         _tmp1_ = gee_bidir_iterator_previous ((GeeBidirIterator*) G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST_ITERATOR, GeeListIterator));
 539         result = _tmp1_;
 540         return result;
 541 }
 542
 543
 544 static gboolean gee_read_only_list_iterator_real_has_previous (GeeBidirIterator* base) {
 545         GeeReadOnlyListIterator * self;
 546         gboolean result = FALSE;
 547         GeeIterator* _tmp0_;
 548         gboolean _tmp1_ = FALSE;
 549         self = (GeeReadOnlyListIterator*) base;
 550         _tmp0_ = ((GeeReadOnlyCollectionIterator*) self)->_iter;
 551         _tmp1_ = gee_bidir_iterator_has_previous ((GeeBidirIterator*) G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST_ITERATOR, GeeListIterator));
 552         result = _tmp1_;
 553         return result;
 554 }
 555
 556
 557 static gboolean gee_read_only_list_iterator_real_last (GeeBidirIterator* base) {
 558         GeeReadOnlyListIterator * self;
 559         gboolean result = FALSE;
 560         GeeIterator* _tmp0_;
 561         gboolean _tmp1_ = FALSE;
 562         self = (GeeReadOnlyListIterator*) base;
 563         _tmp0_ = ((GeeReadOnlyCollectionIterator*) self)->_iter;
 564         _tmp1_ = gee_bidir_iterator_last ((GeeBidirIterator*) G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST_ITERATOR, GeeListIterator));
 565         result = _tmp1_;
 566         return result;
 567 }
 568
 569
 570 static void gee_read_only_list_iterator_real_set (GeeListIterator* base, gconstpointer item) {
 571         GeeReadOnlyListIterator * self;
 572         self = (GeeReadOnlyListIterator*) base;
 573         g_assert_not_reached ();
 574 }
 575
 576
 577 static void gee_read_only_list_iterator_real_insert (GeeListIterator* base, gconstpointer item) {
 578         GeeReadOnlyListIterator * self;
 579         self = (GeeReadOnlyListIterator*) base;
 580         g_assert_not_reached ();
 581 }
 582
 583
 584 static void gee_read_only_list_iterator_real_add (GeeListIterator* base, gconstpointer item) {
 585         GeeReadOnlyListIterator * self;
 586         self = (GeeReadOnlyListIterator*) base;
 587         g_assert_not_reached ();
 588 }
 589
 590
 591 static gint gee_read_only_list_iterator_real_index (GeeListIterator* base) {
 592         GeeReadOnlyListIterator * self;
 593         gint result = 0;
 594         GeeIterator* _tmp0_;
 595         gint _tmp1_ = 0;
 596         self = (GeeReadOnlyListIterator*) base;
 597         _tmp0_ = ((GeeReadOnlyCollectionIterator*) self)->_iter;
 598         _tmp1_ = gee_list_iterator_index (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, GEE_TYPE_LIST_ITERATOR, GeeListIterator));
 599         result = _tmp1_;
 600         return result;
 601 }
 602
 603
 604 static void gee_read_only_list_iterator_class_init (GeeReadOnlyListIteratorClass * klass) {
 605         gee_read_only_list_iterator_parent_class = g_type_class_peek_parent (klass);
 606         g_type_class_add_private (klass, sizeof (GeeReadOnlyListIteratorPrivate));
 607         G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_list_iterator_get_property;
 608         G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_list_iterator_set_property;
 609         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_LIST_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));
 610         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_LIST_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));
 611         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_LIST_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));
 612 }
 613
 614
 615 static void gee_read_only_list_iterator_gee_bidir_iterator_interface_init (GeeBidirIteratorIface * iface) {
 616         gee_read_only_list_iterator_gee_bidir_iterator_parent_iface = g_type_interface_peek_parent (iface);
 617         iface->previous = (gboolean (*)(GeeBidirIterator*)) gee_read_only_list_iterator_real_previous;
 618         iface->has_previous = (gboolean (*)(GeeBidirIterator*)) gee_read_only_list_iterator_real_has_previous;
 619         iface->last = (gboolean (*)(GeeBidirIterator*)) gee_read_only_list_iterator_real_last;
 620 }
 621
 622
 623 static void gee_read_only_list_iterator_gee_list_iterator_interface_init (GeeListIteratorIface * iface) {
 624         gee_read_only_list_iterator_gee_list_iterator_parent_iface = g_type_interface_peek_parent (iface);
 625         iface->set = (void (*)(GeeListIterator*, gconstpointer)) gee_read_only_list_iterator_real_set;
 626         iface->insert = (void (*)(GeeListIterator*, gconstpointer)) gee_read_only_list_iterator_real_insert;
 627         iface->add = (void (*)(GeeListIterator*, gconstpointer)) gee_read_only_list_iterator_real_add;
 628         iface->index = (gint (*)(GeeListIterator*)) gee_read_only_list_iterator_real_index;
 629 }
 630
 631
 632 static void gee_read_only_list_iterator_instance_init (GeeReadOnlyListIterator * self) {
 633         self->priv = GEE_READ_ONLY_LIST_ITERATOR_GET_PRIVATE (self);
 634 }
 635
 636
 637 static GType gee_read_only_list_iterator_get_type (void) {
 638         static volatile gsize gee_read_only_list_iterator_type_id__volatile = 0;
 639         if (g_once_init_enter (&gee_read_only_list_iterator_type_id__volatile)) {
 640                 static const GTypeInfo g_define_type_info = { sizeof (GeeReadOnlyListIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_read_only_list_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeReadOnlyListIterator), 0, (GInstanceInitFunc) gee_read_only_list_iterator_instance_init, NULL };
 641                 static const GInterfaceInfo gee_bidir_iterator_info = { (GInterfaceInitFunc) gee_read_only_list_iterator_gee_bidir_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 642                 static const GInterfaceInfo gee_list_iterator_info = { (GInterfaceInitFunc) gee_read_only_list_iterator_gee_list_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 643                 GType gee_read_only_list_iterator_type_id;
 644                 gee_read_only_list_iterator_type_id = g_type_register_static (GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, "GeeReadOnlyListIterator", &g_define_type_info, 0);
 645                 g_type_add_interface_static (gee_read_only_list_iterator_type_id, GEE_TYPE_BIDIR_ITERATOR, &gee_bidir_iterator_info);
 646                 g_type_add_interface_static (gee_read_only_list_iterator_type_id, GEE_TYPE_LIST_ITERATOR, &gee_list_iterator_info);
 647                 g_once_init_leave (&gee_read_only_list_iterator_type_id__volatile, gee_read_only_list_iterator_type_id);
 648         }
 649         return gee_read_only_list_iterator_type_id__volatile;
 650 }
 651
 652
 653 static void _vala_gee_read_only_list_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 654         GeeReadOnlyListIterator * self;
 655         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_LIST_TYPE_ITERATOR, GeeReadOnlyListIterator);
 656         switch (property_id) {
 657                 default:
 658                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 659                 break;
 660         }
 661 }
 662
 663
 664 static void _vala_gee_read_only_list_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 665         GeeReadOnlyListIterator * self;
 666         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_LIST_TYPE_ITERATOR, GeeReadOnlyListIterator);
 667         switch (property_id) {
 668                 case GEE_READ_ONLY_LIST_ITERATOR_G_TYPE:
 669                 self->priv->g_type = g_value_get_gtype (value);
 670                 break;
 671                 case GEE_READ_ONLY_LIST_ITERATOR_G_DUP_FUNC:
 672                 self->priv->g_dup_func = g_value_get_pointer (value);
 673                 break;
 674                 case GEE_READ_ONLY_LIST_ITERATOR_G_DESTROY_FUNC:
 675                 self->priv->g_destroy_func = g_value_get_pointer (value);
 676                 break;
 677                 default:
 678                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 679                 break;
 680         }
 681 }
 682
 683
 684 static void gee_read_only_list_class_init (GeeReadOnlyListClass * klass) {
 685         gee_read_only_list_parent_class = g_type_class_peek_parent (klass);
 686         g_type_class_add_private (klass, sizeof (GeeReadOnlyListPrivate));
 687         GEE_READ_ONLY_LIST_CLASS (klass)->get_read_only_view = gee_read_only_list_real_get_read_only_view;
 688         G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_list_get_property;
 689         G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_list_set_property;
 690         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_LIST_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));
 691         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_LIST_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));
 692         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_LIST_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));
 693         /**
 694          * {@inheritDoc}
 695          */
 696         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_LIST_READ_ONLY_VIEW, g_param_spec_object ("read-only-view", "read-only-view", "read-only-view", GEE_TYPE_LIST, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
 697 }
 698
 699
 700 static void gee_read_only_list_gee_list_interface_init (GeeListIface * iface) {
 701         gee_read_only_list_gee_list_parent_iface = g_type_interface_peek_parent (iface);
 702         iface->list_iterator = (GeeListIterator* (*)(GeeList*)) gee_read_only_list_real_list_iterator;
 703         iface->index_of = (gint (*)(GeeList*, gconstpointer)) gee_read_only_list_real_index_of;
 704         iface->insert = (void (*)(GeeList*, gint, gconstpointer)) gee_read_only_list_real_insert;
 705         iface->remove_at = (gpointer (*)(GeeList*, gint)) gee_read_only_list_real_remove_at;
 706         iface->get = (gpointer (*)(GeeList*, gint)) gee_read_only_list_real_get;
 707         iface->set = (void (*)(GeeList*, gint, gconstpointer)) gee_read_only_list_real_set;
 708         iface->slice = (GeeList* (*)(GeeList*, gint, gint)) gee_read_only_list_real_slice;
 709         iface->first = (gpointer (*)(GeeList*)) gee_read_only_list_real_first;
 710         iface->last = (gpointer (*)(GeeList*)) gee_read_only_list_real_last;
 711         iface->insert_all = (void (*)(GeeList*, gint, GeeCollection*)) gee_read_only_list_real_insert_all;
 712         iface->sort = (void (*)(GeeList*, GCompareFunc)) gee_read_only_list_real_sort;
 713         iface->get_read_only_view = (GeeList* (*) (GeeList *)) gee_read_only_list_get_read_only_view;
 714 }
 715
 716
 717 static void gee_read_only_list_instance_init (GeeReadOnlyList * self) {
 718         self->priv = GEE_READ_ONLY_LIST_GET_PRIVATE (self);
 719 }
 720
 721
 722 /**
 723  * Read-only view for {@link List} collections.
 724  *
 725  * This class decorates any class which implements the {@link List}
 726  * interface by making it read only. Any method which normally modify data will
 727  * throw an error.
 728  *
 729  * @see List
 730  */
 731 GType gee_read_only_list_get_type (void) {
 732         static volatile gsize gee_read_only_list_type_id__volatile = 0;
 733         if (g_once_init_enter (&gee_read_only_list_type_id__volatile)) {
 734                 static const GTypeInfo g_define_type_info = { sizeof (GeeReadOnlyListClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_read_only_list_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeReadOnlyList), 0, (GInstanceInitFunc) gee_read_only_list_instance_init, NULL };
 735                 static const GInterfaceInfo gee_list_info = { (GInterfaceInitFunc) gee_read_only_list_gee_list_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 736                 GType gee_read_only_list_type_id;
 737                 gee_read_only_list_type_id = g_type_register_static (GEE_TYPE_READ_ONLY_COLLECTION, "GeeReadOnlyList", &g_define_type_info, 0);
 738                 g_type_add_interface_static (gee_read_only_list_type_id, GEE_TYPE_LIST, &gee_list_info);
 739                 g_once_init_leave (&gee_read_only_list_type_id__volatile, gee_read_only_list_type_id);
 740         }
 741         return gee_read_only_list_type_id__volatile;
 742 }
 743
 744
 745 static void _vala_gee_read_only_list_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 746         GeeReadOnlyList * self;
 747         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_LIST, GeeReadOnlyList);
 748         switch (property_id) {
 749                 case GEE_READ_ONLY_LIST_READ_ONLY_VIEW:
 750                 g_value_take_object (value, gee_read_only_list_get_read_only_view (self));
 751                 break;
 752                 default:
 753                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 754                 break;
 755         }
 756 }
 757
 758
 759 static void _vala_gee_read_only_list_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 760         GeeReadOnlyList * self;
 761         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_LIST, GeeReadOnlyList);
 762         switch (property_id) {
 763                 case GEE_READ_ONLY_LIST_G_TYPE:
 764                 self->priv->g_type = g_value_get_gtype (value);
 765                 break;
 766                 case GEE_READ_ONLY_LIST_G_DUP_FUNC:
 767                 self->priv->g_dup_func = g_value_get_pointer (value);
 768                 break;
 769                 case GEE_READ_ONLY_LIST_G_DESTROY_FUNC:
 770                 self->priv->g_destroy_func = g_value_get_pointer (value);
 771                 break;
 772                 default:
 773                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 774                 break;
 775         }
 776 }
 777
 778
 779