1 /* readonlycollection.c generated by valac 0.46.6, 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  * Copyright (C) 2010-2014  Maciej Piechotka
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13 
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18 
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
22  *
23  * Author:
24  * 	Jürg Billeter <j@bitron.ch>
25  */
26 
27 #include <glib-object.h>
28 #include <glib.h>
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 typedef gboolean (*GeeForallFunc) (gpointer g, gpointer user_data);
38 typedef enum  {
39 	GEE_TRAVERSABLE_STREAM_YIELD,
40 	GEE_TRAVERSABLE_STREAM_CONTINUE,
41 	GEE_TRAVERSABLE_STREAM_END,
42 	GEE_TRAVERSABLE_STREAM_WAIT
43 } GeeTraversableStream;
44 
45 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
46 
47 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
48 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
49 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
50 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
51 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
52 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
53 
54 typedef struct _GeeLazy GeeLazy;
55 typedef struct _GeeLazyClass GeeLazyClass;
56 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy* * lazy, gpointer user_data);
57 
58 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
59 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
60 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
61 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
62 
63 typedef struct _GeeIterator GeeIterator;
64 typedef struct _GeeIteratorIface GeeIteratorIface;
65 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, gpointer user_data);
66 typedef gpointer (*GeeMapFunc) (gpointer g, gpointer user_data);
67 typedef gboolean (*GeePredicate) (gconstpointer g, gpointer user_data);
68 typedef GeeIterator* (*GeeFlatMapFunc) (gpointer g, gpointer user_data);
69 
70 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
71 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
72 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
73 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
74 
75 typedef struct _GeeIterable GeeIterable;
76 typedef struct _GeeIterableIface GeeIterableIface;
77 
78 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
79 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
80 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
81 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
82 
83 typedef struct _GeeCollection GeeCollection;
84 typedef struct _GeeCollectionIface GeeCollectionIface;
85 
86 #define GEE_TYPE_READ_ONLY_COLLECTION (gee_read_only_collection_get_type ())
87 #define GEE_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection))
88 #define GEE_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
89 #define GEE_IS_READ_ONLY_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_READ_ONLY_COLLECTION))
90 #define GEE_IS_READ_ONLY_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_READ_ONLY_COLLECTION))
91 #define GEE_READ_ONLY_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollectionClass))
92 
93 typedef struct _GeeReadOnlyCollection GeeReadOnlyCollection;
94 typedef struct _GeeReadOnlyCollectionClass GeeReadOnlyCollectionClass;
95 typedef struct _GeeReadOnlyCollectionPrivate GeeReadOnlyCollectionPrivate;
96 enum  {
97 	GEE_READ_ONLY_COLLECTION_0_PROPERTY,
98 	GEE_READ_ONLY_COLLECTION_G_TYPE,
99 	GEE_READ_ONLY_COLLECTION_G_DUP_FUNC,
100 	GEE_READ_ONLY_COLLECTION_G_DESTROY_FUNC,
101 	GEE_READ_ONLY_COLLECTION_SIZE_PROPERTY,
102 	GEE_READ_ONLY_COLLECTION_READ_ONLY_PROPERTY,
103 	GEE_READ_ONLY_COLLECTION_READ_ONLY_VIEW_PROPERTY,
104 	GEE_READ_ONLY_COLLECTION_NUM_PROPERTIES
105 };
106 static GParamSpec* gee_read_only_collection_properties[GEE_READ_ONLY_COLLECTION_NUM_PROPERTIES];
107 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
108 
109 #define GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR (gee_read_only_collection_iterator_get_type ())
110 #define GEE_READ_ONLY_COLLECTION_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator))
111 #define GEE_READ_ONLY_COLLECTION_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIteratorClass))
112 #define GEE_READ_ONLY_COLLECTION_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR))
113 #define GEE_READ_ONLY_COLLECTION_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR))
114 #define GEE_READ_ONLY_COLLECTION_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIteratorClass))
115 
116 typedef struct _GeeReadOnlyCollectionIterator GeeReadOnlyCollectionIterator;
117 typedef struct _GeeReadOnlyCollectionIteratorClass GeeReadOnlyCollectionIteratorClass;
118 typedef struct _GeeReadOnlyCollectionIteratorPrivate GeeReadOnlyCollectionIteratorPrivate;
119 enum  {
120 	GEE_READ_ONLY_COLLECTION_ITERATOR_0_PROPERTY,
121 	GEE_READ_ONLY_COLLECTION_ITERATOR_G_TYPE,
122 	GEE_READ_ONLY_COLLECTION_ITERATOR_G_DUP_FUNC,
123 	GEE_READ_ONLY_COLLECTION_ITERATOR_G_DESTROY_FUNC,
124 	GEE_READ_ONLY_COLLECTION_ITERATOR_VALID_PROPERTY,
125 	GEE_READ_ONLY_COLLECTION_ITERATOR_READ_ONLY_PROPERTY,
126 	GEE_READ_ONLY_COLLECTION_ITERATOR_NUM_PROPERTIES
127 };
128 static GParamSpec* gee_read_only_collection_iterator_properties[GEE_READ_ONLY_COLLECTION_ITERATOR_NUM_PROPERTIES];
129 
130 struct _GeeIteratorIface {
131 	GTypeInterface parent_iface;
132 	gboolean (*next) (GeeIterator* self);
133 	gboolean (*has_next) (GeeIterator* self);
134 	gpointer (*get) (GeeIterator* self);
135 	void (*remove) (GeeIterator* self);
136 	gboolean (*get_valid) (GeeIterator* self);
137 	gboolean (*get_read_only) (GeeIterator* self);
138 };
139 
140 struct _GeeTraversableIface {
141 	GTypeInterface parent_iface;
142 	GType (*get_g_type) (GeeTraversable* self);
143 	GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
144 	GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
145 	gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, gpointer f_target);
146 	GeeIterator* (*stream) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, gpointer f_target, GDestroyNotify f_target_destroy_notify);
147 	gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, gpointer f_target, gpointer seed);
148 	GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, gpointer f_target);
149 	GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, gpointer f_target, gpointer seed);
150 	GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, gpointer pred_target, GDestroyNotify pred_target_destroy_notify);
151 	GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
152 	GType (*get_element_type) (GeeTraversable* self);
153 	GeeIterator* (*flat_map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFlatMapFunc f, gpointer f_target, GDestroyNotify f_target_destroy_notify);
154 	GeeIterator** (*tee) (GeeTraversable* self, guint forks, gint* result_length1);
155 	gpointer (*first_match) (GeeTraversable* self, GeePredicate pred, gpointer pred_target, GDestroyNotify pred_target_destroy_notify);
156 	gboolean (*any_match) (GeeTraversable* self, GeePredicate pred, gpointer pred_target, GDestroyNotify pred_target_destroy_notify);
157 	gboolean (*all_match) (GeeTraversable* self, GeePredicate pred, gpointer pred_target, GDestroyNotify pred_target_destroy_notify);
158 	gpointer (*max) (GeeTraversable* self, GCompareDataFunc compare, gpointer compare_target, GDestroyNotify compare_target_destroy_notify);
159 	gpointer (*min) (GeeTraversable* self, GCompareDataFunc compare, gpointer compare_target, GDestroyNotify compare_target_destroy_notify);
160 	GeeIterator* (*order_by) (GeeTraversable* self, GCompareDataFunc compare, gpointer compare_target, GDestroyNotify compare_target_destroy_notify);
161 };
162 
163 struct _GeeIterableIface {
164 	GTypeInterface parent_iface;
165 	GType (*get_g_type) (GeeIterable* self);
166 	GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
167 	GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
168 	GeeIterator* (*iterator) (GeeIterable* self);
169 };
170 
171 struct _GeeCollectionIface {
172 	GTypeInterface parent_iface;
173 	GType (*get_g_type) (GeeCollection* self);
174 	GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
175 	GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
176 	gboolean (*contains) (GeeCollection* self, gconstpointer item);
177 	gboolean (*add) (GeeCollection* self, gconstpointer item);
178 	gboolean (*remove) (GeeCollection* self, gconstpointer item);
179 	void (*clear) (GeeCollection* self);
180 	gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
181 	gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
182 	gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
183 	gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
184 	gpointer* (*to_array) (GeeCollection* self, gint* result_length1);
185 	gint (*get_size) (GeeCollection* self);
186 	gboolean (*get_is_empty) (GeeCollection* self);
187 	gboolean (*get_read_only) (GeeCollection* self);
188 	GeeCollection* (*get_read_only_view) (GeeCollection* self);
189 	gboolean (*add_all_array) (GeeCollection* self, gpointer* array, gint array_length1);
190 	gboolean (*contains_all_array) (GeeCollection* self, gpointer* array, gint array_length1);
191 	gboolean (*remove_all_array) (GeeCollection* self, gpointer* array, gint array_length1);
192 	gboolean (*add_all_iterator) (GeeCollection* self, GeeIterator* iter);
193 	gboolean (*contains_all_iterator) (GeeCollection* self, GeeIterator* iter);
194 	gboolean (*remove_all_iterator) (GeeCollection* self, GeeIterator* iter);
195 };
196 
197 struct _GeeReadOnlyCollection {
198 	GObject parent_instance;
199 	GeeReadOnlyCollectionPrivate * priv;
200 	GeeCollection* _collection;
201 };
202 
203 struct _GeeReadOnlyCollectionClass {
204 	GObjectClass parent_class;
205 	GeeCollection* (*get_read_only_view) (GeeReadOnlyCollection* self);
206 };
207 
208 struct _GeeReadOnlyCollectionPrivate {
209 	GType g_type;
210 	GBoxedCopyFunc g_dup_func;
211 	GDestroyNotify g_destroy_func;
212 };
213 
214 struct _GeeReadOnlyCollectionIterator {
215 	GObject parent_instance;
216 	GeeReadOnlyCollectionIteratorPrivate * priv;
217 	GeeIterator* _iter;
218 };
219 
220 struct _GeeReadOnlyCollectionIteratorClass {
221 	GObjectClass parent_class;
222 };
223 
224 struct _GeeReadOnlyCollectionIteratorPrivate {
225 	GType g_type;
226 	GBoxedCopyFunc g_dup_func;
227 	GDestroyNotify g_destroy_func;
228 };
229 
230 static gint GeeReadOnlyCollection_private_offset;
231 static gpointer gee_read_only_collection_parent_class = NULL;
232 static gint GeeReadOnlyCollectionIterator_private_offset;
233 static gpointer gee_read_only_collection_iterator_parent_class = NULL;
234 static GeeTraversableIface * gee_read_only_collection_iterator_gee_traversable_parent_iface = NULL;
235 static GeeIteratorIface * gee_read_only_collection_iterator_gee_iterator_parent_iface = NULL;
236 static GeeTraversableIface * gee_read_only_collection_gee_traversable_parent_iface = NULL;
237 static GeeIterableIface * gee_read_only_collection_gee_iterable_parent_iface = NULL;
238 static GeeCollectionIface * gee_read_only_collection_gee_collection_parent_iface = NULL;
239 
240 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
241 gpointer gee_lazy_ref (gpointer instance);
242 void gee_lazy_unref (gpointer instance);
243 GParamSpec* gee_param_spec_lazy (const gchar* name,
244                                  const gchar* nick,
245                                  const gchar* blurb,
246                                  GType object_type,
247                                  GParamFlags flags);
248 void gee_value_set_lazy (GValue* value,
249                          gpointer v_object);
250 void gee_value_take_lazy (GValue* value,
251                           gpointer v_object);
252 gpointer gee_value_get_lazy (const GValue* value);
253 GType gee_lazy_get_type (void) G_GNUC_CONST;
254 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GeeLazy, gee_lazy_unref)
255 GType gee_iterator_get_type (void) G_GNUC_CONST;
256 GType gee_traversable_get_type (void) G_GNUC_CONST;
257 GType gee_iterable_get_type (void) G_GNUC_CONST;
258 GType gee_collection_get_type (void) G_GNUC_CONST;
259 G_GNUC_INTERNAL GType gee_read_only_collection_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
260 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GeeReadOnlyCollection, g_object_unref)
261 G_GNUC_INTERNAL GeeReadOnlyCollection* gee_read_only_collection_new (GType g_type,
262                                                      GBoxedCopyFunc g_dup_func,
263                                                      GDestroyNotify g_destroy_func,
264                                                      GeeCollection* collection);
265 G_GNUC_INTERNAL GeeReadOnlyCollection* gee_read_only_collection_construct (GType object_type,
266                                                            GType g_type,
267                                                            GBoxedCopyFunc g_dup_func,
268                                                            GDestroyNotify g_destroy_func,
269                                                            GeeCollection* collection);
270 static gboolean gee_read_only_collection_real_foreach (GeeTraversable* base,
271                                                 GeeForallFunc f,
272                                                 gpointer f_target);
273 gboolean gee_traversable_foreach (GeeTraversable* self,
274                                   GeeForallFunc f,
275                                   gpointer f_target);
276 static GeeIterator* gee_read_only_collection_real_stream (GeeTraversable* base,
277                                                    GType a_type,
278                                                    GBoxedCopyFunc a_dup_func,
279                                                    GDestroyNotify a_destroy_func,
280                                                    GeeStreamFunc f,
281                                                    gpointer f_target,
282                                                    GDestroyNotify f_target_destroy_notify);
283 GeeIterator* gee_traversable_stream (GeeTraversable* self,
284                                      GType a_type,
285                                      GBoxedCopyFunc a_dup_func,
286                                      GDestroyNotify a_destroy_func,
287                                      GeeStreamFunc f,
288                                      gpointer f_target,
289                                      GDestroyNotify f_target_destroy_notify);
290 static GeeIterator* gee_read_only_collection_real_filter (GeeTraversable* base,
291                                                    GeePredicate f,
292                                                    gpointer f_target,
293                                                    GDestroyNotify f_target_destroy_notify);
294 GeeIterator* gee_traversable_filter (GeeTraversable* self,
295                                      GeePredicate pred,
296                                      gpointer pred_target,
297                                      GDestroyNotify pred_target_destroy_notify);
298 static GeeIterator* gee_read_only_collection_real_chop (GeeTraversable* base,
299                                                  gint offset,
300                                                  gint length);
301 GeeIterator* gee_traversable_chop (GeeTraversable* self,
302                                    gint offset,
303                                    gint length);
304 static GeeIterator* gee_read_only_collection_real_iterator (GeeIterable* base);
305 GeeIterator* gee_iterable_iterator (GeeIterable* self);
306 G_GNUC_INTERNAL GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_new (GType g_type,
307                                                                       GBoxedCopyFunc g_dup_func,
308                                                                       GDestroyNotify g_destroy_func,
309                                                                       GeeIterator* iterator);
310 G_GNUC_INTERNAL GeeReadOnlyCollectionIterator* gee_read_only_collection_iterator_construct (GType object_type,
311                                                                             GType g_type,
312                                                                             GBoxedCopyFunc g_dup_func,
313                                                                             GDestroyNotify g_destroy_func,
314                                                                             GeeIterator* iterator);
315 GType gee_read_only_collection_iterator_get_type (void) G_GNUC_CONST;
316 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GeeReadOnlyCollectionIterator, g_object_unref)
317 static gboolean gee_read_only_collection_real_contains (GeeCollection* base,
318                                                  gconstpointer item);
319 gboolean gee_collection_contains (GeeCollection* self,
320                                   gconstpointer item);
321 static gboolean gee_read_only_collection_real_add (GeeCollection* base,
322                                             gconstpointer item);
323 static gboolean gee_read_only_collection_real_remove (GeeCollection* base,
324                                                gconstpointer item);
325 static void gee_read_only_collection_real_clear (GeeCollection* base);
326 static gboolean gee_read_only_collection_real_add_all (GeeCollection* base,
327                                                 GeeCollection* collection);
328 static gboolean gee_read_only_collection_real_contains_all (GeeCollection* base,
329                                                      GeeCollection* collection);
330 gboolean gee_collection_contains_all (GeeCollection* self,
331                                       GeeCollection* collection);
332 static gboolean gee_read_only_collection_real_remove_all (GeeCollection* base,
333                                                    GeeCollection* collection);
334 static gboolean gee_read_only_collection_real_retain_all (GeeCollection* base,
335                                                    GeeCollection* collection);
336 static gpointer* gee_read_only_collection_real_to_array (GeeCollection* base,
337                                                   gint* result_length1);
338 gpointer* gee_collection_to_array (GeeCollection* self,
339                                    gint* result_length1);
340 gint gee_collection_get_size (GeeCollection* self);
341 gboolean gee_collection_get_is_empty (GeeCollection* self);
342 G_GNUC_INTERNAL GeeCollection* gee_read_only_collection_get_read_only_view (GeeReadOnlyCollection* self);
343 static gboolean gee_read_only_collection_iterator_real_next (GeeIterator* base);
344 gboolean gee_iterator_next (GeeIterator* self);
345 static gboolean gee_read_only_collection_iterator_real_has_next (GeeIterator* base);
346 gboolean gee_iterator_has_next (GeeIterator* self);
347 static gpointer gee_read_only_collection_iterator_real_get (GeeIterator* base);
348 gpointer gee_iterator_get (GeeIterator* self);
349 static void gee_read_only_collection_iterator_real_remove (GeeIterator* base);
350 static gboolean gee_read_only_collection_iterator_real_foreach (GeeTraversable* base,
351                                                          GeeForallFunc f,
352                                                          gpointer f_target);
353 static GeeIterator* gee_read_only_collection_iterator_real_stream (GeeTraversable* base,
354                                                             GType a_type,
355                                                             GBoxedCopyFunc a_dup_func,
356                                                             GDestroyNotify a_destroy_func,
357                                                             GeeStreamFunc f,
358                                                             gpointer f_target,
359                                                             GDestroyNotify f_target_destroy_notify);
360 static GeeIterator* gee_read_only_collection_iterator_real_filter (GeeTraversable* base,
361                                                             GeePredicate f,
362                                                             gpointer f_target,
363                                                             GDestroyNotify f_target_destroy_notify);
364 static GeeIterator* gee_read_only_collection_iterator_real_chop (GeeTraversable* base,
365                                                           gint offset,
366                                                           gint length);
367 static GeeIterator** gee_read_only_collection_iterator_real_tee (GeeTraversable* base,
368                                                           guint forks,
369                                                           gint* result_length1);
370 GeeIterator** gee_traversable_tee (GeeTraversable* self,
371                                    guint forks,
372                                    gint* result_length1);
373 gboolean gee_iterator_get_valid (GeeIterator* self);
374 static void gee_read_only_collection_iterator_finalize (GObject * obj);
375 gboolean gee_iterator_get_read_only (GeeIterator* self);
376 static void _vala_gee_read_only_collection_iterator_get_property (GObject * object,
377                                                            guint property_id,
378                                                            GValue * value,
379                                                            GParamSpec * pspec);
380 static void _vala_gee_read_only_collection_iterator_set_property (GObject * object,
381                                                            guint property_id,
382                                                            const GValue * value,
383                                                            GParamSpec * pspec);
384 static void gee_read_only_collection_finalize (GObject * obj);
385 gboolean gee_collection_get_read_only (GeeCollection* self);
386 static void _vala_gee_read_only_collection_get_property (GObject * object,
387                                                   guint property_id,
388                                                   GValue * value,
389                                                   GParamSpec * pspec);
390 static void _vala_gee_read_only_collection_set_property (GObject * object,
391                                                   guint property_id,
392                                                   const GValue * value,
393                                                   GParamSpec * pspec);
394 static void _vala_array_destroy (gpointer array,
395                           gint array_length,
396                           GDestroyNotify destroy_func);
397 static void _vala_array_free (gpointer array,
398                        gint array_length,
399                        GDestroyNotify destroy_func);
400 
401 static inline gpointer
gee_read_only_collection_get_instance_private(GeeReadOnlyCollection * self)402 gee_read_only_collection_get_instance_private (GeeReadOnlyCollection* self)
403 {
404 	return G_STRUCT_MEMBER_P (self, GeeReadOnlyCollection_private_offset);
405 }
406 
407 /**
408  * Constructs a read-only collection that mirrors the content of the
409  * specified collection.
410  *
411  * @param collection the collection to decorate.
412  */
413 static gpointer
_g_object_ref0(gpointer self)414 _g_object_ref0 (gpointer self)
415 {
416 	return self ? g_object_ref (self) : NULL;
417 }
418 
419 G_GNUC_INTERNAL GeeReadOnlyCollection*
gee_read_only_collection_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GeeCollection * collection)420 gee_read_only_collection_construct (GType object_type,
421                                     GType g_type,
422                                     GBoxedCopyFunc g_dup_func,
423                                     GDestroyNotify g_destroy_func,
424                                     GeeCollection* collection)
425 {
426 	GeeReadOnlyCollection * self = NULL;
427 	GeeCollection* _tmp0_;
428 	g_return_val_if_fail (collection != NULL, NULL);
429 	self = (GeeReadOnlyCollection*) g_object_new (object_type, NULL);
430 	self->priv->g_type = g_type;
431 	self->priv->g_dup_func = g_dup_func;
432 	self->priv->g_destroy_func = g_destroy_func;
433 	_tmp0_ = _g_object_ref0 (collection);
434 	_g_object_unref0 (self->_collection);
435 	self->_collection = _tmp0_;
436 	return self;
437 }
438 
439 G_GNUC_INTERNAL GeeReadOnlyCollection*
gee_read_only_collection_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GeeCollection * collection)440 gee_read_only_collection_new (GType g_type,
441                               GBoxedCopyFunc g_dup_func,
442                               GDestroyNotify g_destroy_func,
443                               GeeCollection* collection)
444 {
445 	return gee_read_only_collection_construct (GEE_TYPE_READ_ONLY_COLLECTION, g_type, g_dup_func, g_destroy_func, collection);
446 }
447 
448 /**
449  * {@inheritDoc}
450  */
451 static gboolean
gee_read_only_collection_real_foreach(GeeTraversable * base,GeeForallFunc f,gpointer f_target)452 gee_read_only_collection_real_foreach (GeeTraversable* base,
453                                        GeeForallFunc f,
454                                        gpointer f_target)
455 {
456 	GeeReadOnlyCollection * self;
457 	GeeCollection* _tmp0_;
458 	gboolean result = FALSE;
459 	self = (GeeReadOnlyCollection*) base;
460 	_tmp0_ = self->_collection;
461 	result = gee_traversable_foreach ((GeeTraversable*) _tmp0_, f, f_target);
462 	return result;
463 }
464 
465 /**
466  * {@inheritDoc}
467  */
468 static GeeIterator*
gee_read_only_collection_real_stream(GeeTraversable * base,GType a_type,GBoxedCopyFunc a_dup_func,GDestroyNotify a_destroy_func,GeeStreamFunc f,gpointer f_target,GDestroyNotify f_target_destroy_notify)469 gee_read_only_collection_real_stream (GeeTraversable* base,
470                                       GType a_type,
471                                       GBoxedCopyFunc a_dup_func,
472                                       GDestroyNotify a_destroy_func,
473                                       GeeStreamFunc f,
474                                       gpointer f_target,
475                                       GDestroyNotify f_target_destroy_notify)
476 {
477 	GeeReadOnlyCollection * self;
478 	GeeCollection* _tmp0_;
479 	GeeStreamFunc _tmp1_;
480 	gpointer _tmp1__target;
481 	GDestroyNotify _tmp1__target_destroy_notify;
482 	GeeIterator* _tmp2_;
483 	GeeIterator* result = NULL;
484 	self = (GeeReadOnlyCollection*) base;
485 	_tmp0_ = self->_collection;
486 	_tmp1_ = f;
487 	_tmp1__target = f_target;
488 	_tmp1__target_destroy_notify = f_target_destroy_notify;
489 	f = NULL;
490 	f_target = NULL;
491 	f_target_destroy_notify = NULL;
492 	_tmp2_ = gee_traversable_stream ((GeeTraversable*) _tmp0_, a_type, (GBoxedCopyFunc) a_dup_func, (GDestroyNotify) a_destroy_func, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
493 	result = _tmp2_;
494 	(f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
495 	f = NULL;
496 	f_target = NULL;
497 	f_target_destroy_notify = NULL;
498 	return result;
499 }
500 
501 /**
502  * {@inheritDoc}
503  */
504 static GeeIterator*
gee_read_only_collection_real_filter(GeeTraversable * base,GeePredicate f,gpointer f_target,GDestroyNotify f_target_destroy_notify)505 gee_read_only_collection_real_filter (GeeTraversable* base,
506                                       GeePredicate f,
507                                       gpointer f_target,
508                                       GDestroyNotify f_target_destroy_notify)
509 {
510 	GeeReadOnlyCollection * self;
511 	GeeCollection* _tmp0_;
512 	GeePredicate _tmp1_;
513 	gpointer _tmp1__target;
514 	GDestroyNotify _tmp1__target_destroy_notify;
515 	GeeIterator* _tmp2_;
516 	GeeIterator* result = NULL;
517 	self = (GeeReadOnlyCollection*) base;
518 	_tmp0_ = self->_collection;
519 	_tmp1_ = f;
520 	_tmp1__target = f_target;
521 	_tmp1__target_destroy_notify = f_target_destroy_notify;
522 	f = NULL;
523 	f_target = NULL;
524 	f_target_destroy_notify = NULL;
525 	_tmp2_ = gee_traversable_filter ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
526 	result = _tmp2_;
527 	(f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
528 	f = NULL;
529 	f_target = NULL;
530 	f_target_destroy_notify = NULL;
531 	return result;
532 }
533 
534 /**
535  * {@inheritDoc}
536  */
537 static GeeIterator*
gee_read_only_collection_real_chop(GeeTraversable * base,gint offset,gint length)538 gee_read_only_collection_real_chop (GeeTraversable* base,
539                                     gint offset,
540                                     gint length)
541 {
542 	GeeReadOnlyCollection * self;
543 	GeeCollection* _tmp0_;
544 	GeeIterator* _tmp1_;
545 	GeeIterator* result = NULL;
546 	self = (GeeReadOnlyCollection*) base;
547 	_tmp0_ = self->_collection;
548 	_tmp1_ = gee_traversable_chop ((GeeTraversable*) _tmp0_, offset, length);
549 	result = _tmp1_;
550 	return result;
551 }
552 
553 /**
554  * {@inheritDoc}
555  */
556 static GeeIterator*
gee_read_only_collection_real_iterator(GeeIterable * base)557 gee_read_only_collection_real_iterator (GeeIterable* base)
558 {
559 	GeeReadOnlyCollection * self;
560 	GeeCollection* _tmp0_;
561 	GeeIterator* _tmp1_;
562 	GeeIterator* _tmp2_;
563 	GeeReadOnlyCollectionIterator* _tmp3_;
564 	GeeIterator* _tmp4_;
565 	GeeIterator* result = NULL;
566 	self = (GeeReadOnlyCollection*) base;
567 	_tmp0_ = self->_collection;
568 	_tmp1_ = gee_iterable_iterator ((GeeIterable*) _tmp0_);
569 	_tmp2_ = _tmp1_;
570 	_tmp3_ = gee_read_only_collection_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, (GDestroyNotify) self->priv->g_destroy_func, _tmp2_);
571 	_tmp4_ = (GeeIterator*) _tmp3_;
572 	_g_object_unref0 (_tmp2_);
573 	result = _tmp4_;
574 	return result;
575 }
576 
577 /**
578  * {@inheritDoc}
579  */
580 static gboolean
gee_read_only_collection_real_contains(GeeCollection * base,gconstpointer item)581 gee_read_only_collection_real_contains (GeeCollection* base,
582                                         gconstpointer item)
583 {
584 	GeeReadOnlyCollection * self;
585 	GeeCollection* _tmp0_;
586 	gboolean result = FALSE;
587 	self = (GeeReadOnlyCollection*) base;
588 	_tmp0_ = self->_collection;
589 	result = gee_collection_contains (_tmp0_, item);
590 	return result;
591 }
592 
593 /**
594  * Unimplemented method (read only collection).
595  */
596 static gboolean
gee_read_only_collection_real_add(GeeCollection * base,gconstpointer item)597 gee_read_only_collection_real_add (GeeCollection* base,
598                                    gconstpointer item)
599 {
600 	GeeReadOnlyCollection * self;
601 	self = (GeeReadOnlyCollection*) base;
602 	g_assert_not_reached ();
603 }
604 
605 /**
606  * Unimplemented method (read only collection).
607  */
608 static gboolean
gee_read_only_collection_real_remove(GeeCollection * base,gconstpointer item)609 gee_read_only_collection_real_remove (GeeCollection* base,
610                                       gconstpointer item)
611 {
612 	GeeReadOnlyCollection * self;
613 	self = (GeeReadOnlyCollection*) base;
614 	g_assert_not_reached ();
615 }
616 
617 /**
618  * Unimplemented method (read only collection).
619  */
620 static void
gee_read_only_collection_real_clear(GeeCollection * base)621 gee_read_only_collection_real_clear (GeeCollection* base)
622 {
623 	GeeReadOnlyCollection * self;
624 	self = (GeeReadOnlyCollection*) base;
625 	g_assert_not_reached ();
626 }
627 
628 /**
629  * Unimplemented method (read only collection).
630  */
631 static gboolean
gee_read_only_collection_real_add_all(GeeCollection * base,GeeCollection * collection)632 gee_read_only_collection_real_add_all (GeeCollection* base,
633                                        GeeCollection* collection)
634 {
635 	GeeReadOnlyCollection * self;
636 	self = (GeeReadOnlyCollection*) base;
637 	g_return_val_if_fail (collection != NULL, FALSE);
638 	g_assert_not_reached ();
639 }
640 
641 /**
642  * {@inheritDoc}
643  */
644 static gboolean
gee_read_only_collection_real_contains_all(GeeCollection * base,GeeCollection * collection)645 gee_read_only_collection_real_contains_all (GeeCollection* base,
646                                             GeeCollection* collection)
647 {
648 	GeeReadOnlyCollection * self;
649 	GeeCollection* _tmp0_;
650 	gboolean result = FALSE;
651 	self = (GeeReadOnlyCollection*) base;
652 	g_return_val_if_fail (collection != NULL, FALSE);
653 	_tmp0_ = self->_collection;
654 	result = gee_collection_contains_all (_tmp0_, collection);
655 	return result;
656 }
657 
658 /**
659  * Unimplemented method (read only collection).
660  */
661 static gboolean
gee_read_only_collection_real_remove_all(GeeCollection * base,GeeCollection * collection)662 gee_read_only_collection_real_remove_all (GeeCollection* base,
663                                           GeeCollection* collection)
664 {
665 	GeeReadOnlyCollection * self;
666 	self = (GeeReadOnlyCollection*) base;
667 	g_return_val_if_fail (collection != NULL, FALSE);
668 	g_assert_not_reached ();
669 }
670 
671 /**
672  * Unimplemented method (read only collection).
673  */
674 static gboolean
gee_read_only_collection_real_retain_all(GeeCollection * base,GeeCollection * collection)675 gee_read_only_collection_real_retain_all (GeeCollection* base,
676                                           GeeCollection* collection)
677 {
678 	GeeReadOnlyCollection * self;
679 	self = (GeeReadOnlyCollection*) base;
680 	g_return_val_if_fail (collection != NULL, FALSE);
681 	g_assert_not_reached ();
682 }
683 
684 /**
685  * {@inheritDoc}
686  */
687 static gpointer*
gee_read_only_collection_real_to_array(GeeCollection * base,gint * result_length1)688 gee_read_only_collection_real_to_array (GeeCollection* base,
689                                         gint* result_length1)
690 {
691 	GeeReadOnlyCollection * self;
692 	GeeCollection* _tmp0_;
693 	gint _tmp1_ = 0;
694 	gpointer* _tmp2_;
695 	gpointer* _tmp3_;
696 	gint _tmp3__length1;
697 	gpointer* result = NULL;
698 	self = (GeeReadOnlyCollection*) base;
699 	_tmp0_ = self->_collection;
700 	_tmp2_ = gee_collection_to_array (_tmp0_, &_tmp1_);
701 	_tmp3_ = _tmp2_;
702 	_tmp3__length1 = _tmp1_;
703 	if (result_length1) {
704 		*result_length1 = _tmp3__length1;
705 	}
706 	result = _tmp3_;
707 	return result;
708 }
709 
710 static gint
gee_read_only_collection_real_get_size(GeeCollection * base)711 gee_read_only_collection_real_get_size (GeeCollection* base)
712 {
713 	gint result;
714 	GeeReadOnlyCollection* self;
715 	GeeCollection* _tmp0_;
716 	gint _tmp1_;
717 	gint _tmp2_;
718 	self = (GeeReadOnlyCollection*) base;
719 	_tmp0_ = self->_collection;
720 	_tmp1_ = gee_collection_get_size (_tmp0_);
721 	_tmp2_ = _tmp1_;
722 	result = _tmp2_;
723 	return result;
724 }
725 
726 static gboolean
gee_read_only_collection_real_get_is_empty(GeeCollection * base)727 gee_read_only_collection_real_get_is_empty (GeeCollection* base)
728 {
729 	gboolean result;
730 	GeeReadOnlyCollection* self;
731 	GeeCollection* _tmp0_;
732 	gboolean _tmp1_;
733 	gboolean _tmp2_;
734 	self = (GeeReadOnlyCollection*) base;
735 	_tmp0_ = self->_collection;
736 	_tmp1_ = gee_collection_get_is_empty (_tmp0_);
737 	_tmp2_ = _tmp1_;
738 	result = _tmp2_;
739 	return result;
740 }
741 
742 static gboolean
gee_read_only_collection_real_get_read_only(GeeCollection * base)743 gee_read_only_collection_real_get_read_only (GeeCollection* base)
744 {
745 	gboolean result;
746 	GeeReadOnlyCollection* self;
747 	self = (GeeReadOnlyCollection*) base;
748 	result = TRUE;
749 	return result;
750 }
751 
752 static GType
gee_read_only_collection_real_get_element_type(GeeTraversable * base)753 gee_read_only_collection_real_get_element_type (GeeTraversable* base)
754 {
755 	GType result;
756 	GeeReadOnlyCollection* self;
757 	self = (GeeReadOnlyCollection*) base;
758 	result = self->priv->g_type;
759 	return result;
760 }
761 
762 G_GNUC_INTERNAL GeeCollection*
gee_read_only_collection_get_read_only_view(GeeReadOnlyCollection * self)763 gee_read_only_collection_get_read_only_view (GeeReadOnlyCollection* self)
764 {
765 	g_return_val_if_fail (self != NULL, NULL);
766 	return GEE_READ_ONLY_COLLECTION_GET_CLASS (self)->get_read_only_view (self);
767 }
768 
769 static GeeCollection*
gee_read_only_collection_real_get_read_only_view(GeeReadOnlyCollection * base)770 gee_read_only_collection_real_get_read_only_view (GeeReadOnlyCollection* base)
771 {
772 	GeeCollection* result;
773 	GeeReadOnlyCollection* self;
774 	GeeCollection* _tmp0_;
775 	self = base;
776 	_tmp0_ = _g_object_ref0 ((GeeCollection*) self);
777 	result = _tmp0_;
778 	return result;
779 }
780 
781 static inline gpointer
gee_read_only_collection_iterator_get_instance_private(GeeReadOnlyCollectionIterator * self)782 gee_read_only_collection_iterator_get_instance_private (GeeReadOnlyCollectionIterator* self)
783 {
784 	return G_STRUCT_MEMBER_P (self, GeeReadOnlyCollectionIterator_private_offset);
785 }
786 
787 G_GNUC_INTERNAL GeeReadOnlyCollectionIterator*
gee_read_only_collection_iterator_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GeeIterator * iterator)788 gee_read_only_collection_iterator_construct (GType object_type,
789                                              GType g_type,
790                                              GBoxedCopyFunc g_dup_func,
791                                              GDestroyNotify g_destroy_func,
792                                              GeeIterator* iterator)
793 {
794 	GeeReadOnlyCollectionIterator * self = NULL;
795 	GeeIterator* _tmp0_;
796 	g_return_val_if_fail (iterator != NULL, NULL);
797 	self = (GeeReadOnlyCollectionIterator*) g_object_new (object_type, NULL);
798 	self->priv->g_type = g_type;
799 	self->priv->g_dup_func = g_dup_func;
800 	self->priv->g_destroy_func = g_destroy_func;
801 	_tmp0_ = _g_object_ref0 (iterator);
802 	_g_object_unref0 (self->_iter);
803 	self->_iter = _tmp0_;
804 	return self;
805 }
806 
807 G_GNUC_INTERNAL GeeReadOnlyCollectionIterator*
gee_read_only_collection_iterator_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GeeIterator * iterator)808 gee_read_only_collection_iterator_new (GType g_type,
809                                        GBoxedCopyFunc g_dup_func,
810                                        GDestroyNotify g_destroy_func,
811                                        GeeIterator* iterator)
812 {
813 	return gee_read_only_collection_iterator_construct (GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, iterator);
814 }
815 
816 static gboolean
gee_read_only_collection_iterator_real_next(GeeIterator * base)817 gee_read_only_collection_iterator_real_next (GeeIterator* base)
818 {
819 	GeeReadOnlyCollectionIterator * self;
820 	GeeIterator* _tmp0_;
821 	gboolean result = FALSE;
822 	self = (GeeReadOnlyCollectionIterator*) base;
823 	_tmp0_ = self->_iter;
824 	result = gee_iterator_next (_tmp0_);
825 	return result;
826 }
827 
828 static gboolean
gee_read_only_collection_iterator_real_has_next(GeeIterator * base)829 gee_read_only_collection_iterator_real_has_next (GeeIterator* base)
830 {
831 	GeeReadOnlyCollectionIterator * self;
832 	GeeIterator* _tmp0_;
833 	gboolean result = FALSE;
834 	self = (GeeReadOnlyCollectionIterator*) base;
835 	_tmp0_ = self->_iter;
836 	result = gee_iterator_has_next (_tmp0_);
837 	return result;
838 }
839 
840 static gpointer
gee_read_only_collection_iterator_real_get(GeeIterator * base)841 gee_read_only_collection_iterator_real_get (GeeIterator* base)
842 {
843 	GeeReadOnlyCollectionIterator * self;
844 	GeeIterator* _tmp0_;
845 	gpointer _tmp1_;
846 	gpointer result = NULL;
847 	self = (GeeReadOnlyCollectionIterator*) base;
848 	_tmp0_ = self->_iter;
849 	_tmp1_ = gee_iterator_get (_tmp0_);
850 	result = _tmp1_;
851 	return result;
852 }
853 
854 static void
gee_read_only_collection_iterator_real_remove(GeeIterator * base)855 gee_read_only_collection_iterator_real_remove (GeeIterator* base)
856 {
857 	GeeReadOnlyCollectionIterator * self;
858 	self = (GeeReadOnlyCollectionIterator*) base;
859 	g_assert_not_reached ();
860 }
861 
862 static gboolean
gee_read_only_collection_iterator_real_foreach(GeeTraversable * base,GeeForallFunc f,gpointer f_target)863 gee_read_only_collection_iterator_real_foreach (GeeTraversable* base,
864                                                 GeeForallFunc f,
865                                                 gpointer f_target)
866 {
867 	GeeReadOnlyCollectionIterator * self;
868 	GeeIterator* _tmp0_;
869 	gboolean result = FALSE;
870 	self = (GeeReadOnlyCollectionIterator*) base;
871 	_tmp0_ = self->_iter;
872 	result = gee_traversable_foreach ((GeeTraversable*) _tmp0_, f, f_target);
873 	return result;
874 }
875 
876 static GeeIterator*
gee_read_only_collection_iterator_real_stream(GeeTraversable * base,GType a_type,GBoxedCopyFunc a_dup_func,GDestroyNotify a_destroy_func,GeeStreamFunc f,gpointer f_target,GDestroyNotify f_target_destroy_notify)877 gee_read_only_collection_iterator_real_stream (GeeTraversable* base,
878                                                GType a_type,
879                                                GBoxedCopyFunc a_dup_func,
880                                                GDestroyNotify a_destroy_func,
881                                                GeeStreamFunc f,
882                                                gpointer f_target,
883                                                GDestroyNotify f_target_destroy_notify)
884 {
885 	GeeReadOnlyCollectionIterator * self;
886 	GeeIterator* _tmp0_;
887 	GeeStreamFunc _tmp1_;
888 	gpointer _tmp1__target;
889 	GDestroyNotify _tmp1__target_destroy_notify;
890 	GeeIterator* _tmp2_;
891 	GeeIterator* result = NULL;
892 	self = (GeeReadOnlyCollectionIterator*) base;
893 	_tmp0_ = self->_iter;
894 	_tmp1_ = f;
895 	_tmp1__target = f_target;
896 	_tmp1__target_destroy_notify = f_target_destroy_notify;
897 	f = NULL;
898 	f_target = NULL;
899 	f_target_destroy_notify = NULL;
900 	_tmp2_ = gee_traversable_stream ((GeeTraversable*) _tmp0_, a_type, (GBoxedCopyFunc) a_dup_func, (GDestroyNotify) a_destroy_func, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
901 	result = _tmp2_;
902 	(f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
903 	f = NULL;
904 	f_target = NULL;
905 	f_target_destroy_notify = NULL;
906 	return result;
907 }
908 
909 static GeeIterator*
gee_read_only_collection_iterator_real_filter(GeeTraversable * base,GeePredicate f,gpointer f_target,GDestroyNotify f_target_destroy_notify)910 gee_read_only_collection_iterator_real_filter (GeeTraversable* base,
911                                                GeePredicate f,
912                                                gpointer f_target,
913                                                GDestroyNotify f_target_destroy_notify)
914 {
915 	GeeReadOnlyCollectionIterator * self;
916 	GeeIterator* _tmp0_;
917 	GeePredicate _tmp1_;
918 	gpointer _tmp1__target;
919 	GDestroyNotify _tmp1__target_destroy_notify;
920 	GeeIterator* _tmp2_;
921 	GeeIterator* result = NULL;
922 	self = (GeeReadOnlyCollectionIterator*) base;
923 	_tmp0_ = self->_iter;
924 	_tmp1_ = f;
925 	_tmp1__target = f_target;
926 	_tmp1__target_destroy_notify = f_target_destroy_notify;
927 	f = NULL;
928 	f_target = NULL;
929 	f_target_destroy_notify = NULL;
930 	_tmp2_ = gee_traversable_filter ((GeeTraversable*) _tmp0_, _tmp1_, _tmp1__target, _tmp1__target_destroy_notify);
931 	result = _tmp2_;
932 	(f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL);
933 	f = NULL;
934 	f_target = NULL;
935 	f_target_destroy_notify = NULL;
936 	return result;
937 }
938 
939 static GeeIterator*
gee_read_only_collection_iterator_real_chop(GeeTraversable * base,gint offset,gint length)940 gee_read_only_collection_iterator_real_chop (GeeTraversable* base,
941                                              gint offset,
942                                              gint length)
943 {
944 	GeeReadOnlyCollectionIterator * self;
945 	GeeIterator* _tmp0_;
946 	GeeIterator* _tmp1_;
947 	GeeIterator* result = NULL;
948 	self = (GeeReadOnlyCollectionIterator*) base;
949 	_tmp0_ = self->_iter;
950 	_tmp1_ = gee_traversable_chop ((GeeTraversable*) _tmp0_, offset, length);
951 	result = _tmp1_;
952 	return result;
953 }
954 
955 static GeeIterator**
gee_read_only_collection_iterator_real_tee(GeeTraversable * base,guint forks,gint * result_length1)956 gee_read_only_collection_iterator_real_tee (GeeTraversable* base,
957                                             guint forks,
958                                             gint* result_length1)
959 {
960 	GeeReadOnlyCollectionIterator * self;
961 	GeeIterator** result = NULL;
962 	self = (GeeReadOnlyCollectionIterator*) base;
963 	if (forks == ((guint) 0)) {
964 		GeeIterator** _tmp0_;
965 		GeeIterator** _tmp1_;
966 		gint _tmp1__length1;
967 		_tmp0_ = g_new0 (GeeIterator*, 0 + 1);
968 		_tmp1_ = _tmp0_;
969 		_tmp1__length1 = 0;
970 		if (result_length1) {
971 			*result_length1 = _tmp1__length1;
972 		}
973 		result = _tmp1_;
974 		return result;
975 	} else {
976 		GeeIterator** iters = NULL;
977 		GeeIterator* _tmp2_;
978 		gint _tmp3_ = 0;
979 		GeeIterator** _tmp4_;
980 		gint iters_length1;
981 		gint _iters_size_;
982 		GeeIterator** _result_ = NULL;
983 		GeeIterator** _tmp5_;
984 		gint _result__length1;
985 		gint __result__size_;
986 		GeeIterator** _tmp6_;
987 		gint _tmp6__length1;
988 		GeeIterator* _tmp7_;
989 		GeeIterator* _tmp8_;
990 		GeeIterator** _tmp21_;
991 		gint _tmp21__length1;
992 		_tmp2_ = self->_iter;
993 		_tmp4_ = gee_traversable_tee ((GeeTraversable*) _tmp2_, forks, &_tmp3_);
994 		iters = _tmp4_;
995 		iters_length1 = _tmp3_;
996 		_iters_size_ = iters_length1;
997 		_tmp5_ = g_new0 (GeeIterator*, forks + 1);
998 		_result_ = _tmp5_;
999 		_result__length1 = forks;
1000 		__result__size_ = _result__length1;
1001 		_tmp6_ = iters;
1002 		_tmp6__length1 = iters_length1;
1003 		_tmp7_ = _tmp6_[0];
1004 		_tmp8_ = self->_iter;
1005 		if (_tmp7_ == _tmp8_) {
1006 			GeeIterator** _tmp9_;
1007 			gint _tmp9__length1;
1008 			GeeIterator* _tmp10_;
1009 			_tmp9_ = _result_;
1010 			_tmp9__length1 = _result__length1;
1011 			_tmp10_ = _g_object_ref0 ((GeeIterator*) self);
1012 			_g_object_unref0 (_tmp9_[0]);
1013 			_tmp9_[0] = _tmp10_;
1014 		} else {
1015 			GeeIterator** _tmp11_;
1016 			gint _tmp11__length1;
1017 			GeeIterator** _tmp12_;
1018 			gint _tmp12__length1;
1019 			GeeIterator* _tmp13_;
1020 			GeeReadOnlyCollectionIterator* _tmp14_;
1021 			_tmp11_ = _result_;
1022 			_tmp11__length1 = _result__length1;
1023 			_tmp12_ = iters;
1024 			_tmp12__length1 = iters_length1;
1025 			_tmp13_ = _tmp12_[0];
1026 			_tmp14_ = gee_read_only_collection_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, (GDestroyNotify) self->priv->g_destroy_func, _tmp13_);
1027 			_g_object_unref0 (_tmp11_[0]);
1028 			_tmp11_[0] = (GeeIterator*) _tmp14_;
1029 		}
1030 		{
1031 			guint i = 0U;
1032 			i = (guint) 1;
1033 			{
1034 				gboolean _tmp15_ = FALSE;
1035 				_tmp15_ = TRUE;
1036 				while (TRUE) {
1037 					GeeIterator** _tmp17_;
1038 					gint _tmp17__length1;
1039 					GeeIterator** _tmp18_;
1040 					gint _tmp18__length1;
1041 					GeeIterator* _tmp19_;
1042 					GeeReadOnlyCollectionIterator* _tmp20_;
1043 					if (!_tmp15_) {
1044 						guint _tmp16_;
1045 						_tmp16_ = i;
1046 						i = _tmp16_ + 1;
1047 					}
1048 					_tmp15_ = FALSE;
1049 					if (!(i < forks)) {
1050 						break;
1051 					}
1052 					_tmp17_ = _result_;
1053 					_tmp17__length1 = _result__length1;
1054 					_tmp18_ = iters;
1055 					_tmp18__length1 = iters_length1;
1056 					_tmp19_ = _tmp18_[i];
1057 					_tmp20_ = gee_read_only_collection_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, (GDestroyNotify) self->priv->g_destroy_func, _tmp19_);
1058 					_g_object_unref0 (_tmp17_[i]);
1059 					_tmp17_[i] = (GeeIterator*) _tmp20_;
1060 				}
1061 			}
1062 		}
1063 		_tmp21_ = _result_;
1064 		_tmp21__length1 = _result__length1;
1065 		if (result_length1) {
1066 			*result_length1 = _tmp21__length1;
1067 		}
1068 		result = _tmp21_;
1069 		iters = (_vala_array_free (iters, iters_length1, (GDestroyNotify) g_object_unref), NULL);
1070 		return result;
1071 	}
1072 }
1073 
1074 static gboolean
gee_read_only_collection_iterator_real_get_valid(GeeIterator * base)1075 gee_read_only_collection_iterator_real_get_valid (GeeIterator* base)
1076 {
1077 	gboolean result;
1078 	GeeReadOnlyCollectionIterator* self;
1079 	GeeIterator* _tmp0_;
1080 	gboolean _tmp1_;
1081 	gboolean _tmp2_;
1082 	self = (GeeReadOnlyCollectionIterator*) base;
1083 	_tmp0_ = self->_iter;
1084 	_tmp1_ = gee_iterator_get_valid (_tmp0_);
1085 	_tmp2_ = _tmp1_;
1086 	result = _tmp2_;
1087 	return result;
1088 }
1089 
1090 static gboolean
gee_read_only_collection_iterator_real_get_read_only(GeeIterator * base)1091 gee_read_only_collection_iterator_real_get_read_only (GeeIterator* base)
1092 {
1093 	gboolean result;
1094 	GeeReadOnlyCollectionIterator* self;
1095 	self = (GeeReadOnlyCollectionIterator*) base;
1096 	result = TRUE;
1097 	return result;
1098 }
1099 
1100 static GType
gee_read_only_collection_iterator_real_get_element_type(GeeTraversable * base)1101 gee_read_only_collection_iterator_real_get_element_type (GeeTraversable* base)
1102 {
1103 	GType result;
1104 	GeeReadOnlyCollectionIterator* self;
1105 	self = (GeeReadOnlyCollectionIterator*) base;
1106 	result = self->priv->g_type;
1107 	return result;
1108 }
1109 
1110 static void
gee_read_only_collection_iterator_class_init(GeeReadOnlyCollectionIteratorClass * klass,gpointer klass_data)1111 gee_read_only_collection_iterator_class_init (GeeReadOnlyCollectionIteratorClass * klass,
1112                                               gpointer klass_data)
1113 {
1114 	gee_read_only_collection_iterator_parent_class = g_type_class_peek_parent (klass);
1115 	g_type_class_adjust_private_offset (klass, &GeeReadOnlyCollectionIterator_private_offset);
1116 	G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_collection_iterator_get_property;
1117 	G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_collection_iterator_set_property;
1118 	G_OBJECT_CLASS (klass)->finalize = gee_read_only_collection_iterator_finalize;
1119 	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_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1120 	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_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1121 	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_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1122 	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_ITERATOR_VALID_PROPERTY, gee_read_only_collection_iterator_properties[GEE_READ_ONLY_COLLECTION_ITERATOR_VALID_PROPERTY] = g_param_spec_boolean ("valid", "valid", "valid", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1123 	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_ITERATOR_READ_ONLY_PROPERTY, gee_read_only_collection_iterator_properties[GEE_READ_ONLY_COLLECTION_ITERATOR_READ_ONLY_PROPERTY] = g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1124 }
1125 
1126 static GType
gee_read_only_collection_iterator_gee_traversable_get_g_type(GeeReadOnlyCollectionIterator * self)1127 gee_read_only_collection_iterator_gee_traversable_get_g_type (GeeReadOnlyCollectionIterator* self)
1128 {
1129 	return self->priv->g_type;
1130 }
1131 
1132 static GBoxedCopyFunc
gee_read_only_collection_iterator_gee_traversable_get_g_dup_func(GeeReadOnlyCollectionIterator * self)1133 gee_read_only_collection_iterator_gee_traversable_get_g_dup_func (GeeReadOnlyCollectionIterator* self)
1134 {
1135 	return self->priv->g_dup_func;
1136 }
1137 
1138 static GDestroyNotify
gee_read_only_collection_iterator_gee_traversable_get_g_destroy_func(GeeReadOnlyCollectionIterator * self)1139 gee_read_only_collection_iterator_gee_traversable_get_g_destroy_func (GeeReadOnlyCollectionIterator* self)
1140 {
1141 	return self->priv->g_destroy_func;
1142 }
1143 
1144 static void
gee_read_only_collection_iterator_gee_traversable_interface_init(GeeTraversableIface * iface,gpointer iface_data)1145 gee_read_only_collection_iterator_gee_traversable_interface_init (GeeTraversableIface * iface,
1146                                                                   gpointer iface_data)
1147 {
1148 	gee_read_only_collection_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
1149 	iface->foreach = (gboolean (*) (GeeTraversable*, GeeForallFunc, gpointer)) gee_read_only_collection_iterator_real_foreach;
1150 	iface->stream = (GeeIterator* (*) (GeeTraversable*, GType, GBoxedCopyFunc, GDestroyNotify, GeeStreamFunc, gpointer, GDestroyNotify)) gee_read_only_collection_iterator_real_stream;
1151 	iface->filter = (GeeIterator* (*) (GeeTraversable*, GeePredicate, gpointer, GDestroyNotify)) gee_read_only_collection_iterator_real_filter;
1152 	iface->chop = (GeeIterator* (*) (GeeTraversable*, gint, gint)) gee_read_only_collection_iterator_real_chop;
1153 	iface->tee = (GeeIterator** (*) (GeeTraversable*, guint, gint*)) gee_read_only_collection_iterator_real_tee;
1154 	iface->get_g_type = (GType (*) (GeeTraversable *)) gee_read_only_collection_iterator_gee_traversable_get_g_type;
1155 	iface->get_g_dup_func = (GBoxedCopyFunc (*) (GeeTraversable *)) gee_read_only_collection_iterator_gee_traversable_get_g_dup_func;
1156 	iface->get_g_destroy_func = (GDestroyNotify (*) (GeeTraversable *)) gee_read_only_collection_iterator_gee_traversable_get_g_destroy_func;
1157 	iface->get_element_type = gee_read_only_collection_iterator_real_get_element_type;
1158 }
1159 
1160 static void
gee_read_only_collection_iterator_gee_iterator_interface_init(GeeIteratorIface * iface,gpointer iface_data)1161 gee_read_only_collection_iterator_gee_iterator_interface_init (GeeIteratorIface * iface,
1162                                                                gpointer iface_data)
1163 {
1164 	gee_read_only_collection_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
1165 	iface->next = (gboolean (*) (GeeIterator*)) gee_read_only_collection_iterator_real_next;
1166 	iface->has_next = (gboolean (*) (GeeIterator*)) gee_read_only_collection_iterator_real_has_next;
1167 	iface->get = (gpointer (*) (GeeIterator*)) gee_read_only_collection_iterator_real_get;
1168 	iface->remove = (void (*) (GeeIterator*)) gee_read_only_collection_iterator_real_remove;
1169 	iface->get_valid = gee_read_only_collection_iterator_real_get_valid;
1170 	iface->get_read_only = gee_read_only_collection_iterator_real_get_read_only;
1171 }
1172 
1173 static void
gee_read_only_collection_iterator_instance_init(GeeReadOnlyCollectionIterator * self,gpointer klass)1174 gee_read_only_collection_iterator_instance_init (GeeReadOnlyCollectionIterator * self,
1175                                                  gpointer klass)
1176 {
1177 	self->priv = gee_read_only_collection_iterator_get_instance_private (self);
1178 }
1179 
1180 static void
gee_read_only_collection_iterator_finalize(GObject * obj)1181 gee_read_only_collection_iterator_finalize (GObject * obj)
1182 {
1183 	GeeReadOnlyCollectionIterator * self;
1184 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator);
1185 	_g_object_unref0 (self->_iter);
1186 	G_OBJECT_CLASS (gee_read_only_collection_iterator_parent_class)->finalize (obj);
1187 }
1188 
1189 GType
gee_read_only_collection_iterator_get_type(void)1190 gee_read_only_collection_iterator_get_type (void)
1191 {
1192 	static volatile gsize gee_read_only_collection_iterator_type_id__volatile = 0;
1193 	if (g_once_init_enter (&gee_read_only_collection_iterator_type_id__volatile)) {
1194 		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 };
1195 		static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_read_only_collection_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1196 		static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_read_only_collection_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1197 		GType gee_read_only_collection_iterator_type_id;
1198 		gee_read_only_collection_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeReadOnlyCollectionIterator", &g_define_type_info, 0);
1199 		g_type_add_interface_static (gee_read_only_collection_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
1200 		g_type_add_interface_static (gee_read_only_collection_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
1201 		GeeReadOnlyCollectionIterator_private_offset = g_type_add_instance_private (gee_read_only_collection_iterator_type_id, sizeof (GeeReadOnlyCollectionIteratorPrivate));
1202 		g_once_init_leave (&gee_read_only_collection_iterator_type_id__volatile, gee_read_only_collection_iterator_type_id);
1203 	}
1204 	return gee_read_only_collection_iterator_type_id__volatile;
1205 }
1206 
1207 static void
_vala_gee_read_only_collection_iterator_get_property(GObject * object,guint property_id,GValue * value,GParamSpec * pspec)1208 _vala_gee_read_only_collection_iterator_get_property (GObject * object,
1209                                                       guint property_id,
1210                                                       GValue * value,
1211                                                       GParamSpec * pspec)
1212 {
1213 	GeeReadOnlyCollectionIterator * self;
1214 	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator);
1215 	switch (property_id) {
1216 		case GEE_READ_ONLY_COLLECTION_ITERATOR_VALID_PROPERTY:
1217 		g_value_set_boolean (value, gee_iterator_get_valid ((GeeIterator*) self));
1218 		break;
1219 		case GEE_READ_ONLY_COLLECTION_ITERATOR_READ_ONLY_PROPERTY:
1220 		g_value_set_boolean (value, gee_iterator_get_read_only ((GeeIterator*) self));
1221 		break;
1222 		case GEE_READ_ONLY_COLLECTION_ITERATOR_G_TYPE:
1223 		g_value_set_gtype (value, self->priv->g_type);
1224 		break;
1225 		case GEE_READ_ONLY_COLLECTION_ITERATOR_G_DUP_FUNC:
1226 		g_value_set_pointer (value, self->priv->g_dup_func);
1227 		break;
1228 		case GEE_READ_ONLY_COLLECTION_ITERATOR_G_DESTROY_FUNC:
1229 		g_value_set_pointer (value, self->priv->g_destroy_func);
1230 		break;
1231 		default:
1232 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1233 		break;
1234 	}
1235 }
1236 
1237 static void
_vala_gee_read_only_collection_iterator_set_property(GObject * object,guint property_id,const GValue * value,GParamSpec * pspec)1238 _vala_gee_read_only_collection_iterator_set_property (GObject * object,
1239                                                       guint property_id,
1240                                                       const GValue * value,
1241                                                       GParamSpec * pspec)
1242 {
1243 	GeeReadOnlyCollectionIterator * self;
1244 	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_READ_ONLY_COLLECTION_TYPE_ITERATOR, GeeReadOnlyCollectionIterator);
1245 	switch (property_id) {
1246 		case GEE_READ_ONLY_COLLECTION_ITERATOR_G_TYPE:
1247 		self->priv->g_type = g_value_get_gtype (value);
1248 		break;
1249 		case GEE_READ_ONLY_COLLECTION_ITERATOR_G_DUP_FUNC:
1250 		self->priv->g_dup_func = g_value_get_pointer (value);
1251 		break;
1252 		case GEE_READ_ONLY_COLLECTION_ITERATOR_G_DESTROY_FUNC:
1253 		self->priv->g_destroy_func = g_value_get_pointer (value);
1254 		break;
1255 		default:
1256 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1257 		break;
1258 	}
1259 }
1260 
1261 static void
gee_read_only_collection_class_init(GeeReadOnlyCollectionClass * klass,gpointer klass_data)1262 gee_read_only_collection_class_init (GeeReadOnlyCollectionClass * klass,
1263                                      gpointer klass_data)
1264 {
1265 	gee_read_only_collection_parent_class = g_type_class_peek_parent (klass);
1266 	g_type_class_adjust_private_offset (klass, &GeeReadOnlyCollection_private_offset);
1267 	GEE_READ_ONLY_COLLECTION_CLASS (klass)->get_read_only_view = gee_read_only_collection_real_get_read_only_view;
1268 	G_OBJECT_CLASS (klass)->get_property = _vala_gee_read_only_collection_get_property;
1269 	G_OBJECT_CLASS (klass)->set_property = _vala_gee_read_only_collection_set_property;
1270 	G_OBJECT_CLASS (klass)->finalize = gee_read_only_collection_finalize;
1271 	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_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1272 	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_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1273 	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_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
1274 	/**
1275 	 * {@inheritDoc}
1276 	 */
1277 	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_SIZE_PROPERTY, gee_read_only_collection_properties[GEE_READ_ONLY_COLLECTION_SIZE_PROPERTY] = g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1278 	/**
1279 	 * {@inheritDoc}
1280 	 */
1281 	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_READ_ONLY_PROPERTY, gee_read_only_collection_properties[GEE_READ_ONLY_COLLECTION_READ_ONLY_PROPERTY] = g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1282 	g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_READ_ONLY_COLLECTION_READ_ONLY_VIEW_PROPERTY, gee_read_only_collection_properties[GEE_READ_ONLY_COLLECTION_READ_ONLY_VIEW_PROPERTY] = g_param_spec_object ("read-only-view", "read-only-view", "read-only-view", GEE_TYPE_COLLECTION, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1283 }
1284 
1285 static GType
gee_read_only_collection_gee_traversable_get_g_type(GeeReadOnlyCollection * self)1286 gee_read_only_collection_gee_traversable_get_g_type (GeeReadOnlyCollection* self)
1287 {
1288 	return self->priv->g_type;
1289 }
1290 
1291 static GBoxedCopyFunc
gee_read_only_collection_gee_traversable_get_g_dup_func(GeeReadOnlyCollection * self)1292 gee_read_only_collection_gee_traversable_get_g_dup_func (GeeReadOnlyCollection* self)
1293 {
1294 	return self->priv->g_dup_func;
1295 }
1296 
1297 static GDestroyNotify
gee_read_only_collection_gee_traversable_get_g_destroy_func(GeeReadOnlyCollection * self)1298 gee_read_only_collection_gee_traversable_get_g_destroy_func (GeeReadOnlyCollection* self)
1299 {
1300 	return self->priv->g_destroy_func;
1301 }
1302 
1303 static void
gee_read_only_collection_gee_traversable_interface_init(GeeTraversableIface * iface,gpointer iface_data)1304 gee_read_only_collection_gee_traversable_interface_init (GeeTraversableIface * iface,
1305                                                          gpointer iface_data)
1306 {
1307 	gee_read_only_collection_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
1308 	iface->foreach = (gboolean (*) (GeeTraversable*, GeeForallFunc, gpointer)) gee_read_only_collection_real_foreach;
1309 	iface->stream = (GeeIterator* (*) (GeeTraversable*, GType, GBoxedCopyFunc, GDestroyNotify, GeeStreamFunc, gpointer, GDestroyNotify)) gee_read_only_collection_real_stream;
1310 	iface->filter = (GeeIterator* (*) (GeeTraversable*, GeePredicate, gpointer, GDestroyNotify)) gee_read_only_collection_real_filter;
1311 	iface->chop = (GeeIterator* (*) (GeeTraversable*, gint, gint)) gee_read_only_collection_real_chop;
1312 	iface->get_g_type = (GType (*) (GeeTraversable *)) gee_read_only_collection_gee_traversable_get_g_type;
1313 	iface->get_g_dup_func = (GBoxedCopyFunc (*) (GeeTraversable *)) gee_read_only_collection_gee_traversable_get_g_dup_func;
1314 	iface->get_g_destroy_func = (GDestroyNotify (*) (GeeTraversable *)) gee_read_only_collection_gee_traversable_get_g_destroy_func;
1315 	iface->get_element_type = gee_read_only_collection_real_get_element_type;
1316 }
1317 
1318 static GType
gee_read_only_collection_gee_iterable_get_g_type(GeeReadOnlyCollection * self)1319 gee_read_only_collection_gee_iterable_get_g_type (GeeReadOnlyCollection* self)
1320 {
1321 	return self->priv->g_type;
1322 }
1323 
1324 static GBoxedCopyFunc
gee_read_only_collection_gee_iterable_get_g_dup_func(GeeReadOnlyCollection * self)1325 gee_read_only_collection_gee_iterable_get_g_dup_func (GeeReadOnlyCollection* self)
1326 {
1327 	return self->priv->g_dup_func;
1328 }
1329 
1330 static GDestroyNotify
gee_read_only_collection_gee_iterable_get_g_destroy_func(GeeReadOnlyCollection * self)1331 gee_read_only_collection_gee_iterable_get_g_destroy_func (GeeReadOnlyCollection* self)
1332 {
1333 	return self->priv->g_destroy_func;
1334 }
1335 
1336 static void
gee_read_only_collection_gee_iterable_interface_init(GeeIterableIface * iface,gpointer iface_data)1337 gee_read_only_collection_gee_iterable_interface_init (GeeIterableIface * iface,
1338                                                       gpointer iface_data)
1339 {
1340 	gee_read_only_collection_gee_iterable_parent_iface = g_type_interface_peek_parent (iface);
1341 	iface->iterator = (GeeIterator* (*) (GeeIterable*)) gee_read_only_collection_real_iterator;
1342 	iface->get_g_type = (GType (*) (GeeIterable *)) gee_read_only_collection_gee_iterable_get_g_type;
1343 	iface->get_g_dup_func = (GBoxedCopyFunc (*) (GeeIterable *)) gee_read_only_collection_gee_iterable_get_g_dup_func;
1344 	iface->get_g_destroy_func = (GDestroyNotify (*) (GeeIterable *)) gee_read_only_collection_gee_iterable_get_g_destroy_func;
1345 }
1346 
1347 static GType
gee_read_only_collection_gee_collection_get_g_type(GeeReadOnlyCollection * self)1348 gee_read_only_collection_gee_collection_get_g_type (GeeReadOnlyCollection* self)
1349 {
1350 	return self->priv->g_type;
1351 }
1352 
1353 static GBoxedCopyFunc
gee_read_only_collection_gee_collection_get_g_dup_func(GeeReadOnlyCollection * self)1354 gee_read_only_collection_gee_collection_get_g_dup_func (GeeReadOnlyCollection* self)
1355 {
1356 	return self->priv->g_dup_func;
1357 }
1358 
1359 static GDestroyNotify
gee_read_only_collection_gee_collection_get_g_destroy_func(GeeReadOnlyCollection * self)1360 gee_read_only_collection_gee_collection_get_g_destroy_func (GeeReadOnlyCollection* self)
1361 {
1362 	return self->priv->g_destroy_func;
1363 }
1364 
1365 static void
gee_read_only_collection_gee_collection_interface_init(GeeCollectionIface * iface,gpointer iface_data)1366 gee_read_only_collection_gee_collection_interface_init (GeeCollectionIface * iface,
1367                                                         gpointer iface_data)
1368 {
1369 	gee_read_only_collection_gee_collection_parent_iface = g_type_interface_peek_parent (iface);
1370 	iface->contains = (gboolean (*) (GeeCollection*, gconstpointer)) gee_read_only_collection_real_contains;
1371 	iface->add = (gboolean (*) (GeeCollection*, gconstpointer)) gee_read_only_collection_real_add;
1372 	iface->remove = (gboolean (*) (GeeCollection*, gconstpointer)) gee_read_only_collection_real_remove;
1373 	iface->clear = (void (*) (GeeCollection*)) gee_read_only_collection_real_clear;
1374 	iface->add_all = (gboolean (*) (GeeCollection*, GeeCollection*)) gee_read_only_collection_real_add_all;
1375 	iface->contains_all = (gboolean (*) (GeeCollection*, GeeCollection*)) gee_read_only_collection_real_contains_all;
1376 	iface->remove_all = (gboolean (*) (GeeCollection*, GeeCollection*)) gee_read_only_collection_real_remove_all;
1377 	iface->retain_all = (gboolean (*) (GeeCollection*, GeeCollection*)) gee_read_only_collection_real_retain_all;
1378 	iface->to_array = (gpointer* (*) (GeeCollection*, gint*)) gee_read_only_collection_real_to_array;
1379 	iface->get_g_type = (GType (*) (GeeCollection *)) gee_read_only_collection_gee_collection_get_g_type;
1380 	iface->get_g_dup_func = (GBoxedCopyFunc (*) (GeeCollection *)) gee_read_only_collection_gee_collection_get_g_dup_func;
1381 	iface->get_g_destroy_func = (GDestroyNotify (*) (GeeCollection *)) gee_read_only_collection_gee_collection_get_g_destroy_func;
1382 	iface->get_size = gee_read_only_collection_real_get_size;
1383 	iface->get_is_empty = gee_read_only_collection_real_get_is_empty;
1384 	iface->get_read_only = gee_read_only_collection_real_get_read_only;
1385 	iface->get_read_only_view = (GeeCollection* (*) (GeeCollection *)) gee_read_only_collection_get_read_only_view;
1386 }
1387 
1388 static void
gee_read_only_collection_instance_init(GeeReadOnlyCollection * self,gpointer klass)1389 gee_read_only_collection_instance_init (GeeReadOnlyCollection * self,
1390                                         gpointer klass)
1391 {
1392 	self->priv = gee_read_only_collection_get_instance_private (self);
1393 }
1394 
1395 static void
gee_read_only_collection_finalize(GObject * obj)1396 gee_read_only_collection_finalize (GObject * obj)
1397 {
1398 	GeeReadOnlyCollection * self;
1399 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection);
1400 	_g_object_unref0 (self->_collection);
1401 	G_OBJECT_CLASS (gee_read_only_collection_parent_class)->finalize (obj);
1402 }
1403 
1404 /**
1405  * Read-only view for {@link Collection} collections.
1406  *
1407  * This class decorates any class which implements the {@link Collection}
1408  * interface by making it read only. Any method which normally modify data will
1409  * throw an error.
1410  *
1411  * @see Collection
1412  */
1413 G_GNUC_INTERNAL GType
gee_read_only_collection_get_type(void)1414 gee_read_only_collection_get_type (void)
1415 {
1416 	static volatile gsize gee_read_only_collection_type_id__volatile = 0;
1417 	if (g_once_init_enter (&gee_read_only_collection_type_id__volatile)) {
1418 		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 };
1419 		static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_read_only_collection_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1420 		static const GInterfaceInfo gee_iterable_info = { (GInterfaceInitFunc) gee_read_only_collection_gee_iterable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1421 		static const GInterfaceInfo gee_collection_info = { (GInterfaceInitFunc) gee_read_only_collection_gee_collection_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1422 		GType gee_read_only_collection_type_id;
1423 		gee_read_only_collection_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeReadOnlyCollection", &g_define_type_info, 0);
1424 		g_type_add_interface_static (gee_read_only_collection_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
1425 		g_type_add_interface_static (gee_read_only_collection_type_id, GEE_TYPE_ITERABLE, &gee_iterable_info);
1426 		g_type_add_interface_static (gee_read_only_collection_type_id, GEE_TYPE_COLLECTION, &gee_collection_info);
1427 		GeeReadOnlyCollection_private_offset = g_type_add_instance_private (gee_read_only_collection_type_id, sizeof (GeeReadOnlyCollectionPrivate));
1428 		g_once_init_leave (&gee_read_only_collection_type_id__volatile, gee_read_only_collection_type_id);
1429 	}
1430 	return gee_read_only_collection_type_id__volatile;
1431 }
1432 
1433 static void
_vala_gee_read_only_collection_get_property(GObject * object,guint property_id,GValue * value,GParamSpec * pspec)1434 _vala_gee_read_only_collection_get_property (GObject * object,
1435                                              guint property_id,
1436                                              GValue * value,
1437                                              GParamSpec * pspec)
1438 {
1439 	GeeReadOnlyCollection * self;
1440 	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection);
1441 	switch (property_id) {
1442 		case GEE_READ_ONLY_COLLECTION_SIZE_PROPERTY:
1443 		g_value_set_int (value, gee_collection_get_size ((GeeCollection*) self));
1444 		break;
1445 		case GEE_READ_ONLY_COLLECTION_READ_ONLY_PROPERTY:
1446 		g_value_set_boolean (value, gee_collection_get_read_only ((GeeCollection*) self));
1447 		break;
1448 		case GEE_READ_ONLY_COLLECTION_READ_ONLY_VIEW_PROPERTY:
1449 		g_value_take_object (value, gee_read_only_collection_get_read_only_view (self));
1450 		break;
1451 		case GEE_READ_ONLY_COLLECTION_G_TYPE:
1452 		g_value_set_gtype (value, self->priv->g_type);
1453 		break;
1454 		case GEE_READ_ONLY_COLLECTION_G_DUP_FUNC:
1455 		g_value_set_pointer (value, self->priv->g_dup_func);
1456 		break;
1457 		case GEE_READ_ONLY_COLLECTION_G_DESTROY_FUNC:
1458 		g_value_set_pointer (value, self->priv->g_destroy_func);
1459 		break;
1460 		default:
1461 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1462 		break;
1463 	}
1464 }
1465 
1466 static void
_vala_gee_read_only_collection_set_property(GObject * object,guint property_id,const GValue * value,GParamSpec * pspec)1467 _vala_gee_read_only_collection_set_property (GObject * object,
1468                                              guint property_id,
1469                                              const GValue * value,
1470                                              GParamSpec * pspec)
1471 {
1472 	GeeReadOnlyCollection * self;
1473 	self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_READ_ONLY_COLLECTION, GeeReadOnlyCollection);
1474 	switch (property_id) {
1475 		case GEE_READ_ONLY_COLLECTION_G_TYPE:
1476 		self->priv->g_type = g_value_get_gtype (value);
1477 		break;
1478 		case GEE_READ_ONLY_COLLECTION_G_DUP_FUNC:
1479 		self->priv->g_dup_func = g_value_get_pointer (value);
1480 		break;
1481 		case GEE_READ_ONLY_COLLECTION_G_DESTROY_FUNC:
1482 		self->priv->g_destroy_func = g_value_get_pointer (value);
1483 		break;
1484 		default:
1485 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1486 		break;
1487 	}
1488 }
1489 
1490 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)1491 _vala_array_destroy (gpointer array,
1492                      gint array_length,
1493                      GDestroyNotify destroy_func)
1494 {
1495 	if ((array != NULL) && (destroy_func != NULL)) {
1496 		int i;
1497 		for (i = 0; i < array_length; i = i + 1) {
1498 			if (((gpointer*) array)[i] != NULL) {
1499 				destroy_func (((gpointer*) array)[i]);
1500 			}
1501 		}
1502 	}
1503 }
1504 
1505 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)1506 _vala_array_free (gpointer array,
1507                   gint array_length,
1508                   GDestroyNotify destroy_func)
1509 {
1510 	_vala_array_destroy (array, array_length, destroy_func);
1511 	g_free (array);
1512 }
1513 
1514