1 /* arraylist.c generated by valac, the Vala compiler
2 * generated from arraylist.vala, do not modify */
3
4 /* arraylist.vala
5 *
6 * Copyright (C) 2004-2005 Novell, Inc
7 * Copyright (C) 2005 David Waite
8 * Copyright (C) 2007-2008 Jürg Billeter
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 *
24 * Author:
25 * Jürg Billeter <j@bitron.ch>
26 */
27
28 #include "valagee.h"
29 #include <glib.h>
30 #include <glib-object.h>
31 #include <string.h>
32
33 #define VALA_ARRAY_LIST_TYPE_ITERATOR (vala_array_list_iterator_get_type ())
34 #define VALA_ARRAY_LIST_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_ARRAY_LIST_TYPE_ITERATOR, ValaArrayListIterator))
35 #define VALA_ARRAY_LIST_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_ARRAY_LIST_TYPE_ITERATOR, ValaArrayListIteratorClass))
36 #define VALA_ARRAY_LIST_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_ARRAY_LIST_TYPE_ITERATOR))
37 #define VALA_ARRAY_LIST_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_ARRAY_LIST_TYPE_ITERATOR))
38 #define VALA_ARRAY_LIST_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_ARRAY_LIST_TYPE_ITERATOR, ValaArrayListIteratorClass))
39
40 typedef struct _ValaArrayListIterator ValaArrayListIterator;
41 typedef struct _ValaArrayListIteratorClass ValaArrayListIteratorClass;
42 typedef struct _ValaArrayListIteratorPrivate ValaArrayListIteratorPrivate;
43 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
44 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
45 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
46 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
47 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
48
49 struct _ValaArrayListPrivate {
50 GType g_type;
51 GBoxedCopyFunc g_dup_func;
52 GDestroyNotify g_destroy_func;
53 GEqualFunc _equal_func;
54 gint _stamp;
55 };
56
57 struct _ValaArrayListIterator {
58 ValaIterator parent_instance;
59 gboolean _removed;
60 gint _stamp;
61 ValaArrayListIteratorPrivate * priv;
62 };
63
64 struct _ValaArrayListIteratorClass {
65 ValaIteratorClass parent_class;
66 };
67
68 struct _ValaArrayListIteratorPrivate {
69 GType g_type;
70 GBoxedCopyFunc g_dup_func;
71 GDestroyNotify g_destroy_func;
72 ValaArrayList* _list;
73 gint _index;
74 };
75
76 static gint ValaArrayList_private_offset;
77 static gpointer vala_array_list_parent_class = NULL;
78 static gint ValaArrayListIterator_private_offset;
79 static gpointer vala_array_list_iterator_parent_class = NULL;
80
81 static GType vala_array_list_real_get_element_type (ValaIterable* base);
82 static ValaIterator* vala_array_list_real_iterator (ValaIterable* base);
83 static ValaArrayListIterator* vala_array_list_iterator_new (GType g_type,
84 GBoxedCopyFunc g_dup_func,
85 GDestroyNotify g_destroy_func,
86 ValaArrayList* list);
87 static ValaArrayListIterator* vala_array_list_iterator_construct (GType object_type,
88 GType g_type,
89 GBoxedCopyFunc g_dup_func,
90 GDestroyNotify g_destroy_func,
91 ValaArrayList* list);
92 static GType vala_array_list_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
93 static gboolean vala_array_list_real_contains (ValaCollection* base,
94 gconstpointer item);
95 static gint vala_array_list_real_index_of (ValaList* base,
96 gconstpointer item);
97 static gpointer vala_array_list_real_get (ValaList* base,
98 gint index);
99 static void vala_array_list_real_set (ValaList* base,
100 gint index,
101 gconstpointer item);
102 static gboolean vala_array_list_real_add (ValaCollection* base,
103 gconstpointer item);
104 static void vala_array_list_grow_if_needed (ValaArrayList* self,
105 gint new_count);
106 static void vala_array_list_real_insert (ValaList* base,
107 gint index,
108 gconstpointer item);
109 static void vala_array_list_shift (ValaArrayList* self,
110 gint start,
111 gint delta);
112 static gboolean vala_array_list_real_remove (ValaCollection* base,
113 gconstpointer item);
114 static gpointer vala_array_list_real_remove_at (ValaList* base,
115 gint index);
116 static void vala_array_list_real_clear (ValaCollection* base);
117 static void vala_array_list_set_capacity (ValaArrayList* self,
118 gint value);
119 static void vala_array_list_iterator_set_list (ValaArrayListIterator* self,
120 ValaArrayList* value);
121 static gboolean vala_array_list_iterator_real_next (ValaIterator* base);
122 static gboolean vala_array_list_iterator_real_has_next (ValaIterator* base);
123 static gpointer vala_array_list_iterator_real_get (ValaIterator* base);
124 static void vala_array_list_iterator_real_remove (ValaIterator* base);
125 static void vala_array_list_iterator_finalize (ValaIterator * obj);
126 static GType vala_array_list_iterator_get_type_once (void);
127 static void vala_array_list_finalize (ValaIterable * obj);
128 static GType vala_array_list_get_type_once (void);
129 static void _vala_array_destroy (gpointer array,
130 gint array_length,
131 GDestroyNotify destroy_func);
132 static void _vala_array_free (gpointer array,
133 gint array_length,
134 GDestroyNotify destroy_func);
135 static void _vala_array_move (gpointer array,
136 gsize element_size,
137 gint src,
138 gint dest,
139 gint length);
140
141 static inline gpointer
vala_array_list_get_instance_private(ValaArrayList * self)142 vala_array_list_get_instance_private (ValaArrayList* self)
143 {
144 return G_STRUCT_MEMBER_P (self, ValaArrayList_private_offset);
145 }
146
147 static gint
vala_array_list_real_get_size(ValaCollection * base)148 vala_array_list_real_get_size (ValaCollection* base)
149 {
150 gint result;
151 ValaArrayList* self;
152 self = (ValaArrayList*) base;
153 result = self->_size;
154 return result;
155 }
156
157 void
vala_array_list_set_equal_func(ValaArrayList * self,GEqualFunc value)158 vala_array_list_set_equal_func (ValaArrayList* self,
159 GEqualFunc value)
160 {
161 g_return_if_fail (self != NULL);
162 self->priv->_equal_func = value;
163 }
164
165 ValaArrayList*
vala_array_list_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GEqualFunc equal_func)166 vala_array_list_construct (GType object_type,
167 GType g_type,
168 GBoxedCopyFunc g_dup_func,
169 GDestroyNotify g_destroy_func,
170 GEqualFunc equal_func)
171 {
172 ValaArrayList* self = NULL;
173 self = (ValaArrayList*) vala_list_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, (GDestroyNotify) g_destroy_func);
174 self->priv->g_type = g_type;
175 self->priv->g_dup_func = g_dup_func;
176 self->priv->g_destroy_func = g_destroy_func;
177 vala_array_list_set_equal_func (self, equal_func);
178 return self;
179 }
180
181 ValaArrayList*
vala_array_list_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GEqualFunc equal_func)182 vala_array_list_new (GType g_type,
183 GBoxedCopyFunc g_dup_func,
184 GDestroyNotify g_destroy_func,
185 GEqualFunc equal_func)
186 {
187 return vala_array_list_construct (VALA_TYPE_ARRAY_LIST, g_type, g_dup_func, g_destroy_func, equal_func);
188 }
189
190 static GType
vala_array_list_real_get_element_type(ValaIterable * base)191 vala_array_list_real_get_element_type (ValaIterable* base)
192 {
193 ValaArrayList * self;
194 GType result = 0UL;
195 self = (ValaArrayList*) base;
196 result = self->priv->g_type;
197 return result;
198 }
199
200 static ValaIterator*
vala_array_list_real_iterator(ValaIterable * base)201 vala_array_list_real_iterator (ValaIterable* base)
202 {
203 ValaArrayList * self;
204 ValaArrayListIterator* _tmp0_;
205 ValaIterator* result = NULL;
206 self = (ValaArrayList*) base;
207 _tmp0_ = vala_array_list_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, (GDestroyNotify) self->priv->g_destroy_func, self);
208 result = (ValaIterator*) _tmp0_;
209 return result;
210 }
211
212 static gboolean
vala_array_list_real_contains(ValaCollection * base,gconstpointer item)213 vala_array_list_real_contains (ValaCollection* base,
214 gconstpointer item)
215 {
216 ValaArrayList * self;
217 gboolean result = FALSE;
218 self = (ValaArrayList*) base;
219 result = vala_list_index_of ((ValaList*) self, item) != -1;
220 return result;
221 }
222
223 static gint
vala_array_list_real_index_of(ValaList * base,gconstpointer item)224 vala_array_list_real_index_of (ValaList* base,
225 gconstpointer item)
226 {
227 ValaArrayList * self;
228 gint result = 0;
229 self = (ValaArrayList*) base;
230 {
231 gint index = 0;
232 index = 0;
233 {
234 gboolean _tmp0_ = FALSE;
235 _tmp0_ = TRUE;
236 while (TRUE) {
237 GEqualFunc _tmp2_;
238 gpointer* _tmp3_;
239 gint _tmp3__length1;
240 gconstpointer _tmp4_;
241 if (!_tmp0_) {
242 gint _tmp1_;
243 _tmp1_ = index;
244 index = _tmp1_ + 1;
245 }
246 _tmp0_ = FALSE;
247 if (!(index < self->_size)) {
248 break;
249 }
250 _tmp2_ = self->priv->_equal_func;
251 _tmp3_ = self->_items;
252 _tmp3__length1 = self->_items_length1;
253 _tmp4_ = _tmp3_[index];
254 if (_tmp2_ (_tmp4_, item)) {
255 result = index;
256 return result;
257 }
258 }
259 }
260 }
261 result = -1;
262 return result;
263 }
264
265 static gpointer
vala_array_list_real_get(ValaList * base,gint index)266 vala_array_list_real_get (ValaList* base,
267 gint index)
268 {
269 ValaArrayList * self;
270 gboolean _tmp0_ = FALSE;
271 gpointer* _tmp1_;
272 gint _tmp1__length1;
273 gconstpointer _tmp2_;
274 gpointer _tmp3_;
275 gpointer result = NULL;
276 self = (ValaArrayList*) base;
277 if (index >= 0) {
278 _tmp0_ = index < self->_size;
279 } else {
280 _tmp0_ = FALSE;
281 }
282 _vala_assert (_tmp0_, "index >= 0 && index < _size");
283 _tmp1_ = self->_items;
284 _tmp1__length1 = self->_items_length1;
285 _tmp2_ = _tmp1_[index];
286 _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
287 result = _tmp3_;
288 return result;
289 }
290
291 static void
vala_array_list_real_set(ValaList * base,gint index,gconstpointer item)292 vala_array_list_real_set (ValaList* base,
293 gint index,
294 gconstpointer item)
295 {
296 ValaArrayList * self;
297 gboolean _tmp0_ = FALSE;
298 gpointer* _tmp1_;
299 gint _tmp1__length1;
300 gpointer _tmp2_;
301 self = (ValaArrayList*) base;
302 if (index >= 0) {
303 _tmp0_ = index < self->_size;
304 } else {
305 _tmp0_ = FALSE;
306 }
307 _vala_assert (_tmp0_, "index >= 0 && index < _size");
308 _tmp1_ = self->_items;
309 _tmp1__length1 = self->_items_length1;
310 _tmp2_ = ((item != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) item) : ((gpointer) item);
311 ((_tmp1_[index] == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp1_[index] = (self->priv->g_destroy_func (_tmp1_[index]), NULL));
312 _tmp1_[index] = _tmp2_;
313 }
314
315 static gboolean
vala_array_list_real_add(ValaCollection * base,gconstpointer item)316 vala_array_list_real_add (ValaCollection* base,
317 gconstpointer item)
318 {
319 ValaArrayList * self;
320 gpointer* _tmp0_;
321 gint _tmp0__length1;
322 gpointer* _tmp1_;
323 gint _tmp1__length1;
324 gint _tmp2_;
325 gconstpointer _tmp3_;
326 gpointer _tmp4_;
327 gint _tmp5_;
328 gboolean result = FALSE;
329 self = (ValaArrayList*) base;
330 _tmp0_ = self->_items;
331 _tmp0__length1 = self->_items_length1;
332 if (self->_size == _tmp0__length1) {
333 vala_array_list_grow_if_needed (self, 1);
334 }
335 _tmp1_ = self->_items;
336 _tmp1__length1 = self->_items_length1;
337 _tmp2_ = self->_size;
338 self->_size = _tmp2_ + 1;
339 _tmp3_ = item;
340 _tmp4_ = ((_tmp3_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp3_) : ((gpointer) _tmp3_);
341 ((_tmp1_[_tmp2_] == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp1_[_tmp2_] = (self->priv->g_destroy_func (_tmp1_[_tmp2_]), NULL));
342 _tmp1_[_tmp2_] = _tmp4_;
343 _tmp5_ = self->priv->_stamp;
344 self->priv->_stamp = _tmp5_ + 1;
345 result = TRUE;
346 return result;
347 }
348
349 static void
vala_array_list_real_insert(ValaList * base,gint index,gconstpointer item)350 vala_array_list_real_insert (ValaList* base,
351 gint index,
352 gconstpointer item)
353 {
354 ValaArrayList * self;
355 gboolean _tmp0_ = FALSE;
356 gpointer* _tmp1_;
357 gint _tmp1__length1;
358 gpointer* _tmp2_;
359 gint _tmp2__length1;
360 gpointer _tmp3_;
361 gint _tmp4_;
362 self = (ValaArrayList*) base;
363 if (index >= 0) {
364 _tmp0_ = index <= self->_size;
365 } else {
366 _tmp0_ = FALSE;
367 }
368 _vala_assert (_tmp0_, "index >= 0 && index <= _size");
369 _tmp1_ = self->_items;
370 _tmp1__length1 = self->_items_length1;
371 if (self->_size == _tmp1__length1) {
372 vala_array_list_grow_if_needed (self, 1);
373 }
374 vala_array_list_shift (self, index, 1);
375 _tmp2_ = self->_items;
376 _tmp2__length1 = self->_items_length1;
377 _tmp3_ = ((item != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) item) : ((gpointer) item);
378 ((_tmp2_[index] == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp2_[index] = (self->priv->g_destroy_func (_tmp2_[index]), NULL));
379 _tmp2_[index] = _tmp3_;
380 _tmp4_ = self->priv->_stamp;
381 self->priv->_stamp = _tmp4_ + 1;
382 }
383
384 static gboolean
vala_array_list_real_remove(ValaCollection * base,gconstpointer item)385 vala_array_list_real_remove (ValaCollection* base,
386 gconstpointer item)
387 {
388 ValaArrayList * self;
389 gboolean result = FALSE;
390 self = (ValaArrayList*) base;
391 {
392 gint index = 0;
393 index = 0;
394 {
395 gboolean _tmp0_ = FALSE;
396 _tmp0_ = TRUE;
397 while (TRUE) {
398 GEqualFunc _tmp2_;
399 gpointer* _tmp3_;
400 gint _tmp3__length1;
401 gconstpointer _tmp4_;
402 if (!_tmp0_) {
403 gint _tmp1_;
404 _tmp1_ = index;
405 index = _tmp1_ + 1;
406 }
407 _tmp0_ = FALSE;
408 if (!(index < self->_size)) {
409 break;
410 }
411 _tmp2_ = self->priv->_equal_func;
412 _tmp3_ = self->_items;
413 _tmp3__length1 = self->_items_length1;
414 _tmp4_ = _tmp3_[index];
415 if (_tmp2_ (_tmp4_, item)) {
416 gpointer _tmp5_;
417 gpointer _tmp6_;
418 _tmp5_ = vala_list_remove_at ((ValaList*) self, index);
419 _tmp6_ = _tmp5_;
420 ((_tmp6_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp6_ = (self->priv->g_destroy_func (_tmp6_), NULL));
421 result = TRUE;
422 return result;
423 }
424 }
425 }
426 }
427 result = FALSE;
428 return result;
429 }
430
431 static gpointer
vala_array_list_real_remove_at(ValaList * base,gint index)432 vala_array_list_real_remove_at (ValaList* base,
433 gint index)
434 {
435 ValaArrayList * self;
436 gboolean _tmp0_ = FALSE;
437 gpointer item = NULL;
438 gpointer* _tmp1_;
439 gint _tmp1__length1;
440 gconstpointer _tmp2_;
441 gpointer _tmp3_;
442 gpointer* _tmp4_;
443 gint _tmp4__length1;
444 gint _tmp5_;
445 gpointer result = NULL;
446 self = (ValaArrayList*) base;
447 if (index >= 0) {
448 _tmp0_ = index < self->_size;
449 } else {
450 _tmp0_ = FALSE;
451 }
452 _vala_assert (_tmp0_, "index >= 0 && index < _size");
453 _tmp1_ = self->_items;
454 _tmp1__length1 = self->_items_length1;
455 _tmp2_ = _tmp1_[index];
456 _tmp3_ = ((_tmp2_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
457 item = _tmp3_;
458 _tmp4_ = self->_items;
459 _tmp4__length1 = self->_items_length1;
460 ((_tmp4_[index] == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp4_[index] = (self->priv->g_destroy_func (_tmp4_[index]), NULL));
461 _tmp4_[index] = NULL;
462 vala_array_list_shift (self, index + 1, -1);
463 _tmp5_ = self->priv->_stamp;
464 self->priv->_stamp = _tmp5_ + 1;
465 result = item;
466 return result;
467 }
468
469 static void
vala_array_list_real_clear(ValaCollection * base)470 vala_array_list_real_clear (ValaCollection* base)
471 {
472 ValaArrayList * self;
473 gint _tmp3_;
474 self = (ValaArrayList*) base;
475 {
476 gint index = 0;
477 index = 0;
478 {
479 gboolean _tmp0_ = FALSE;
480 _tmp0_ = TRUE;
481 while (TRUE) {
482 gpointer* _tmp2_;
483 gint _tmp2__length1;
484 if (!_tmp0_) {
485 gint _tmp1_;
486 _tmp1_ = index;
487 index = _tmp1_ + 1;
488 }
489 _tmp0_ = FALSE;
490 if (!(index < self->_size)) {
491 break;
492 }
493 _tmp2_ = self->_items;
494 _tmp2__length1 = self->_items_length1;
495 ((_tmp2_[index] == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp2_[index] = (self->priv->g_destroy_func (_tmp2_[index]), NULL));
496 _tmp2_[index] = NULL;
497 }
498 }
499 }
500 self->_size = 0;
501 _tmp3_ = self->priv->_stamp;
502 self->priv->_stamp = _tmp3_ + 1;
503 }
504
505 static void
vala_array_list_shift(ValaArrayList * self,gint start,gint delta)506 vala_array_list_shift (ValaArrayList* self,
507 gint start,
508 gint delta)
509 {
510 gboolean _tmp0_ = FALSE;
511 gboolean _tmp1_ = FALSE;
512 g_return_if_fail (self != NULL);
513 if (start >= 0) {
514 _tmp1_ = start <= self->_size;
515 } else {
516 _tmp1_ = FALSE;
517 }
518 if (_tmp1_) {
519 _tmp0_ = start >= (-delta);
520 } else {
521 _tmp0_ = FALSE;
522 }
523 _vala_assert (_tmp0_, "start >= 0 && start <= _size && start >= -delta");
524 _vala_array_move (self->_items, sizeof (gpointer), start, start + delta, self->_size - start);
525 self->_size = self->_size + delta;
526 }
527
528 static void
vala_array_list_grow_if_needed(ValaArrayList * self,gint new_count)529 vala_array_list_grow_if_needed (ValaArrayList* self,
530 gint new_count)
531 {
532 gint minimum_size = 0;
533 gpointer* _tmp0_;
534 gint _tmp0__length1;
535 g_return_if_fail (self != NULL);
536 _vala_assert (new_count >= 0, "new_count >= 0");
537 minimum_size = self->_size + new_count;
538 _tmp0_ = self->_items;
539 _tmp0__length1 = self->_items_length1;
540 if (minimum_size > _tmp0__length1) {
541 gint _tmp1_ = 0;
542 gpointer* _tmp2_;
543 gint _tmp2__length1;
544 _tmp2_ = self->_items;
545 _tmp2__length1 = self->_items_length1;
546 if (new_count > _tmp2__length1) {
547 _tmp1_ = minimum_size;
548 } else {
549 gpointer* _tmp3_;
550 gint _tmp3__length1;
551 _tmp3_ = self->_items;
552 _tmp3__length1 = self->_items_length1;
553 _tmp1_ = 2 * _tmp3__length1;
554 }
555 vala_array_list_set_capacity (self, _tmp1_);
556 }
557 }
558
559 static void
vala_array_list_set_capacity(ValaArrayList * self,gint value)560 vala_array_list_set_capacity (ValaArrayList* self,
561 gint value)
562 {
563 gint _tmp0_;
564 g_return_if_fail (self != NULL);
565 _vala_assert (value >= self->_size, "value >= _size");
566 _tmp0_ = value;
567 self->_items = g_renew (gpointer, self->_items, value);
568 (_tmp0_ > self->_items_length1) ? memset (self->_items + self->_items_length1, 0, sizeof (gpointer) * (_tmp0_ - self->_items_length1)) : NULL;
569 self->_items_length1 = _tmp0_;
570 self->__items_size_ = _tmp0_;
571 }
572
573 static inline gpointer
vala_array_list_iterator_get_instance_private(ValaArrayListIterator * self)574 vala_array_list_iterator_get_instance_private (ValaArrayListIterator* self)
575 {
576 return G_STRUCT_MEMBER_P (self, ValaArrayListIterator_private_offset);
577 }
578
579 static gpointer
_vala_iterable_ref0(gpointer self)580 _vala_iterable_ref0 (gpointer self)
581 {
582 return self ? vala_iterable_ref (self) : NULL;
583 }
584
585 static void
vala_array_list_iterator_set_list(ValaArrayListIterator * self,ValaArrayList * value)586 vala_array_list_iterator_set_list (ValaArrayListIterator* self,
587 ValaArrayList* value)
588 {
589 ValaArrayList* _tmp0_;
590 ValaArrayList* _tmp1_;
591 g_return_if_fail (self != NULL);
592 _tmp0_ = _vala_iterable_ref0 (value);
593 _vala_iterable_unref0 (self->priv->_list);
594 self->priv->_list = _tmp0_;
595 _tmp1_ = self->priv->_list;
596 self->_stamp = _tmp1_->priv->_stamp;
597 }
598
599 static ValaArrayListIterator*
vala_array_list_iterator_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,ValaArrayList * list)600 vala_array_list_iterator_construct (GType object_type,
601 GType g_type,
602 GBoxedCopyFunc g_dup_func,
603 GDestroyNotify g_destroy_func,
604 ValaArrayList* list)
605 {
606 ValaArrayListIterator* self = NULL;
607 g_return_val_if_fail (list != NULL, NULL);
608 self = (ValaArrayListIterator*) vala_iterator_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, (GDestroyNotify) g_destroy_func);
609 self->priv->g_type = g_type;
610 self->priv->g_dup_func = g_dup_func;
611 self->priv->g_destroy_func = g_destroy_func;
612 vala_array_list_iterator_set_list (self, list);
613 return self;
614 }
615
616 static ValaArrayListIterator*
vala_array_list_iterator_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,ValaArrayList * list)617 vala_array_list_iterator_new (GType g_type,
618 GBoxedCopyFunc g_dup_func,
619 GDestroyNotify g_destroy_func,
620 ValaArrayList* list)
621 {
622 return vala_array_list_iterator_construct (VALA_ARRAY_LIST_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, list);
623 }
624
625 static gboolean
vala_array_list_iterator_real_next(ValaIterator * base)626 vala_array_list_iterator_real_next (ValaIterator* base)
627 {
628 ValaArrayListIterator * self;
629 ValaArrayList* _tmp0_;
630 ValaArrayList* _tmp1_;
631 ValaArrayList* _tmp3_;
632 gboolean result = FALSE;
633 self = (ValaArrayListIterator*) base;
634 _tmp0_ = self->priv->_list;
635 _vala_assert (self->_stamp == _tmp0_->priv->_stamp, "_stamp == _list._stamp");
636 _tmp1_ = self->priv->_list;
637 if (self->priv->_index < _tmp1_->_size) {
638 gint _tmp2_;
639 _tmp2_ = self->priv->_index;
640 self->priv->_index = _tmp2_ + 1;
641 self->_removed = FALSE;
642 }
643 _tmp3_ = self->priv->_list;
644 result = self->priv->_index < _tmp3_->_size;
645 return result;
646 }
647
648 static gboolean
vala_array_list_iterator_real_has_next(ValaIterator * base)649 vala_array_list_iterator_real_has_next (ValaIterator* base)
650 {
651 ValaArrayListIterator * self;
652 ValaArrayList* _tmp0_;
653 ValaArrayList* _tmp1_;
654 gboolean result = FALSE;
655 self = (ValaArrayListIterator*) base;
656 _tmp0_ = self->priv->_list;
657 _vala_assert (self->_stamp == _tmp0_->priv->_stamp, "_stamp == _list._stamp");
658 _tmp1_ = self->priv->_list;
659 result = (self->priv->_index + 1) < _tmp1_->_size;
660 return result;
661 }
662
663 static gpointer
vala_array_list_iterator_real_get(ValaIterator * base)664 vala_array_list_iterator_real_get (ValaIterator* base)
665 {
666 ValaArrayListIterator * self;
667 ValaArrayList* _tmp0_;
668 gboolean _tmp1_ = FALSE;
669 ValaArrayList* _tmp3_;
670 gpointer _tmp4_;
671 gpointer result = NULL;
672 self = (ValaArrayListIterator*) base;
673 _tmp0_ = self->priv->_list;
674 _vala_assert (self->_stamp == _tmp0_->priv->_stamp, "_stamp == _list._stamp");
675 _vala_assert (!self->_removed, "! _removed");
676 if (self->priv->_index < 0) {
677 _tmp1_ = TRUE;
678 } else {
679 ValaArrayList* _tmp2_;
680 _tmp2_ = self->priv->_list;
681 _tmp1_ = self->priv->_index >= _tmp2_->_size;
682 }
683 if (_tmp1_) {
684 result = NULL;
685 return result;
686 }
687 _tmp3_ = self->priv->_list;
688 _tmp4_ = vala_list_get ((ValaList*) _tmp3_, self->priv->_index);
689 result = _tmp4_;
690 return result;
691 }
692
693 static void
vala_array_list_iterator_real_remove(ValaIterator * base)694 vala_array_list_iterator_real_remove (ValaIterator* base)
695 {
696 ValaArrayListIterator * self;
697 ValaArrayList* _tmp0_;
698 gboolean _tmp1_ = FALSE;
699 ValaArrayList* _tmp2_;
700 ValaArrayList* _tmp3_;
701 gpointer _tmp4_;
702 gpointer _tmp5_;
703 gint _tmp6_;
704 ValaArrayList* _tmp7_;
705 self = (ValaArrayListIterator*) base;
706 _tmp0_ = self->priv->_list;
707 _vala_assert (self->_stamp == _tmp0_->priv->_stamp, "_stamp == _list._stamp");
708 if (!self->_removed) {
709 _tmp1_ = self->priv->_index >= 0;
710 } else {
711 _tmp1_ = FALSE;
712 }
713 _vala_assert (_tmp1_, "! _removed && _index >= 0");
714 _tmp2_ = self->priv->_list;
715 _vala_assert (self->priv->_index < _tmp2_->_size, "_index < _list._size");
716 _tmp3_ = self->priv->_list;
717 _tmp4_ = vala_list_remove_at ((ValaList*) _tmp3_, self->priv->_index);
718 _tmp5_ = _tmp4_;
719 ((_tmp5_ == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp5_ = (self->priv->g_destroy_func (_tmp5_), NULL));
720 _tmp6_ = self->priv->_index;
721 self->priv->_index = _tmp6_ - 1;
722 self->_removed = TRUE;
723 _tmp7_ = self->priv->_list;
724 self->_stamp = _tmp7_->priv->_stamp;
725 }
726
727 static gboolean
vala_array_list_iterator_real_get_valid(ValaIterator * base)728 vala_array_list_iterator_real_get_valid (ValaIterator* base)
729 {
730 gboolean result;
731 ValaArrayListIterator* self;
732 gboolean _tmp0_ = FALSE;
733 gboolean _tmp1_ = FALSE;
734 self = (ValaArrayListIterator*) base;
735 if (self->priv->_index >= 0) {
736 ValaArrayList* _tmp2_;
737 _tmp2_ = self->priv->_list;
738 _tmp1_ = self->priv->_index < _tmp2_->_size;
739 } else {
740 _tmp1_ = FALSE;
741 }
742 if (_tmp1_) {
743 _tmp0_ = !self->_removed;
744 } else {
745 _tmp0_ = FALSE;
746 }
747 result = _tmp0_;
748 return result;
749 }
750
751 static void
vala_array_list_iterator_class_init(ValaArrayListIteratorClass * klass,gpointer klass_data)752 vala_array_list_iterator_class_init (ValaArrayListIteratorClass * klass,
753 gpointer klass_data)
754 {
755 vala_array_list_iterator_parent_class = g_type_class_peek_parent (klass);
756 ((ValaIteratorClass *) klass)->finalize = vala_array_list_iterator_finalize;
757 g_type_class_adjust_private_offset (klass, &ValaArrayListIterator_private_offset);
758 ((ValaIteratorClass *) klass)->next = (gboolean (*) (ValaIterator*)) vala_array_list_iterator_real_next;
759 ((ValaIteratorClass *) klass)->has_next = (gboolean (*) (ValaIterator*)) vala_array_list_iterator_real_has_next;
760 ((ValaIteratorClass *) klass)->get = (gpointer (*) (ValaIterator*)) vala_array_list_iterator_real_get;
761 ((ValaIteratorClass *) klass)->remove = (void (*) (ValaIterator*)) vala_array_list_iterator_real_remove;
762 VALA_ITERATOR_CLASS (klass)->get_valid = vala_array_list_iterator_real_get_valid;
763 }
764
765 static void
vala_array_list_iterator_instance_init(ValaArrayListIterator * self,gpointer klass)766 vala_array_list_iterator_instance_init (ValaArrayListIterator * self,
767 gpointer klass)
768 {
769 self->priv = vala_array_list_iterator_get_instance_private (self);
770 self->priv->_index = -1;
771 self->_removed = FALSE;
772 self->_stamp = 0;
773 }
774
775 static void
vala_array_list_iterator_finalize(ValaIterator * obj)776 vala_array_list_iterator_finalize (ValaIterator * obj)
777 {
778 ValaArrayListIterator * self;
779 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_ARRAY_LIST_TYPE_ITERATOR, ValaArrayListIterator);
780 _vala_iterable_unref0 (self->priv->_list);
781 VALA_ITERATOR_CLASS (vala_array_list_iterator_parent_class)->finalize (obj);
782 }
783
784 static GType
vala_array_list_iterator_get_type_once(void)785 vala_array_list_iterator_get_type_once (void)
786 {
787 static const GTypeInfo g_define_type_info = { sizeof (ValaArrayListIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_array_list_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaArrayListIterator), 0, (GInstanceInitFunc) vala_array_list_iterator_instance_init, NULL };
788 GType vala_array_list_iterator_type_id;
789 vala_array_list_iterator_type_id = g_type_register_static (VALA_TYPE_ITERATOR, "ValaArrayListIterator", &g_define_type_info, 0);
790 ValaArrayListIterator_private_offset = g_type_add_instance_private (vala_array_list_iterator_type_id, sizeof (ValaArrayListIteratorPrivate));
791 return vala_array_list_iterator_type_id;
792 }
793
794 static GType
vala_array_list_iterator_get_type(void)795 vala_array_list_iterator_get_type (void)
796 {
797 static volatile gsize vala_array_list_iterator_type_id__volatile = 0;
798 if (g_once_init_enter (&vala_array_list_iterator_type_id__volatile)) {
799 GType vala_array_list_iterator_type_id;
800 vala_array_list_iterator_type_id = vala_array_list_iterator_get_type_once ();
801 g_once_init_leave (&vala_array_list_iterator_type_id__volatile, vala_array_list_iterator_type_id);
802 }
803 return vala_array_list_iterator_type_id__volatile;
804 }
805
806 static void
vala_array_list_class_init(ValaArrayListClass * klass,gpointer klass_data)807 vala_array_list_class_init (ValaArrayListClass * klass,
808 gpointer klass_data)
809 {
810 vala_array_list_parent_class = g_type_class_peek_parent (klass);
811 ((ValaIterableClass *) klass)->finalize = vala_array_list_finalize;
812 g_type_class_adjust_private_offset (klass, &ValaArrayList_private_offset);
813 ((ValaIterableClass *) klass)->get_element_type = (GType (*) (ValaIterable*)) vala_array_list_real_get_element_type;
814 ((ValaIterableClass *) klass)->iterator = (ValaIterator* (*) (ValaIterable*)) vala_array_list_real_iterator;
815 ((ValaCollectionClass *) klass)->contains = (gboolean (*) (ValaCollection*, gconstpointer)) vala_array_list_real_contains;
816 ((ValaListClass *) klass)->index_of = (gint (*) (ValaList*, gconstpointer)) vala_array_list_real_index_of;
817 ((ValaListClass *) klass)->get = (gpointer (*) (ValaList*, gint)) vala_array_list_real_get;
818 ((ValaListClass *) klass)->set = (void (*) (ValaList*, gint, gconstpointer)) vala_array_list_real_set;
819 ((ValaCollectionClass *) klass)->add = (gboolean (*) (ValaCollection*, gconstpointer)) vala_array_list_real_add;
820 ((ValaListClass *) klass)->insert = (void (*) (ValaList*, gint, gconstpointer)) vala_array_list_real_insert;
821 ((ValaCollectionClass *) klass)->remove = (gboolean (*) (ValaCollection*, gconstpointer)) vala_array_list_real_remove;
822 ((ValaListClass *) klass)->remove_at = (gpointer (*) (ValaList*, gint)) vala_array_list_real_remove_at;
823 ((ValaCollectionClass *) klass)->clear = (void (*) (ValaCollection*)) vala_array_list_real_clear;
824 VALA_COLLECTION_CLASS (klass)->get_size = vala_array_list_real_get_size;
825 }
826
827 static void
vala_array_list_instance_init(ValaArrayList * self,gpointer klass)828 vala_array_list_instance_init (ValaArrayList * self,
829 gpointer klass)
830 {
831 gpointer* _tmp0_;
832 self->priv = vala_array_list_get_instance_private (self);
833 _tmp0_ = g_new0 (gpointer, 4);
834 self->_items = _tmp0_;
835 self->_items_length1 = 4;
836 self->__items_size_ = self->_items_length1;
837 self->priv->_stamp = 0;
838 }
839
840 static void
vala_array_list_finalize(ValaIterable * obj)841 vala_array_list_finalize (ValaIterable * obj)
842 {
843 ValaArrayList * self;
844 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_ARRAY_LIST, ValaArrayList);
845 self->_items = (_vala_array_free (self->_items, self->_items_length1, (GDestroyNotify) self->priv->g_destroy_func), NULL);
846 VALA_ITERABLE_CLASS (vala_array_list_parent_class)->finalize (obj);
847 }
848
849 /**
850 * Arrays of arbitrary elements which grow automatically as elements are added.
851 */
852 static GType
vala_array_list_get_type_once(void)853 vala_array_list_get_type_once (void)
854 {
855 static const GTypeInfo g_define_type_info = { sizeof (ValaArrayListClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_array_list_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaArrayList), 0, (GInstanceInitFunc) vala_array_list_instance_init, NULL };
856 GType vala_array_list_type_id;
857 vala_array_list_type_id = g_type_register_static (VALA_TYPE_LIST, "ValaArrayList", &g_define_type_info, 0);
858 ValaArrayList_private_offset = g_type_add_instance_private (vala_array_list_type_id, sizeof (ValaArrayListPrivate));
859 return vala_array_list_type_id;
860 }
861
862 GType
vala_array_list_get_type(void)863 vala_array_list_get_type (void)
864 {
865 static volatile gsize vala_array_list_type_id__volatile = 0;
866 if (g_once_init_enter (&vala_array_list_type_id__volatile)) {
867 GType vala_array_list_type_id;
868 vala_array_list_type_id = vala_array_list_get_type_once ();
869 g_once_init_leave (&vala_array_list_type_id__volatile, vala_array_list_type_id);
870 }
871 return vala_array_list_type_id__volatile;
872 }
873
874 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)875 _vala_array_destroy (gpointer array,
876 gint array_length,
877 GDestroyNotify destroy_func)
878 {
879 if ((array != NULL) && (destroy_func != NULL)) {
880 gint i;
881 for (i = 0; i < array_length; i = i + 1) {
882 if (((gpointer*) array)[i] != NULL) {
883 destroy_func (((gpointer*) array)[i]);
884 }
885 }
886 }
887 }
888
889 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)890 _vala_array_free (gpointer array,
891 gint array_length,
892 GDestroyNotify destroy_func)
893 {
894 _vala_array_destroy (array, array_length, destroy_func);
895 g_free (array);
896 }
897
898 static void
_vala_array_move(gpointer array,gsize element_size,gint src,gint dest,gint length)899 _vala_array_move (gpointer array,
900 gsize element_size,
901 gint src,
902 gint dest,
903 gint length)
904 {
905 memmove (((char*) array) + (dest * element_size), ((char*) array) + (src * element_size), length * element_size);
906 if ((src < dest) && ((src + length) > dest)) {
907 memset (((char*) array) + (src * element_size), 0, (dest - src) * element_size);
908 } else if ((src > dest) && (src < (dest + length))) {
909 memset (((char*) array) + ((dest + length) * element_size), 0, (src - dest) * element_size);
910 } else if (src != dest) {
911 memset (((char*) array) + (src * element_size), 0, length * element_size);
912 }
913 }
914
915