1 /* hashset.c generated by valac, the Vala compiler
2 * generated from hashset.vala, do not modify */
3
4 /* hashset.vala
5 *
6 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
7 * Copyright (C) 1997-2000 GLib Team and others
8 * Copyright (C) 2007-2009 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
32 typedef struct _ValaHashSetNode ValaHashSetNode;
33
34 #define VALA_HASH_SET_TYPE_ITERATOR (vala_hash_set_iterator_get_type ())
35 #define VALA_HASH_SET_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_HASH_SET_TYPE_ITERATOR, ValaHashSetIterator))
36 #define VALA_HASH_SET_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_HASH_SET_TYPE_ITERATOR, ValaHashSetIteratorClass))
37 #define VALA_HASH_SET_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_HASH_SET_TYPE_ITERATOR))
38 #define VALA_HASH_SET_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_HASH_SET_TYPE_ITERATOR))
39 #define VALA_HASH_SET_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_HASH_SET_TYPE_ITERATOR, ValaHashSetIteratorClass))
40
41 typedef struct _ValaHashSetIterator ValaHashSetIterator;
42 typedef struct _ValaHashSetIteratorClass ValaHashSetIteratorClass;
43 #define _vala_hash_set_node_free0(var) ((var == NULL) ? NULL : (var = (vala_hash_set_node_free (var), NULL)))
44 typedef struct _ValaHashSetIteratorPrivate ValaHashSetIteratorPrivate;
45 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
46 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
47 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
48 #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; }
49 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
50
51 struct _ValaHashSetPrivate {
52 GType g_type;
53 GBoxedCopyFunc g_dup_func;
54 GDestroyNotify g_destroy_func;
55 gint _array_size;
56 gint _nnodes;
57 ValaHashSetNode** _nodes;
58 gint _nodes_length1;
59 gint __nodes_size_;
60 gint _stamp;
61 GHashFunc _hash_func;
62 GEqualFunc _equal_func;
63 };
64
65 struct _ValaHashSetNode {
66 gpointer key;
67 ValaHashSetNode* next;
68 guint key_hash;
69 };
70
71 struct _ValaHashSetIterator {
72 ValaIterator parent_instance;
73 ValaHashSetIteratorPrivate * priv;
74 };
75
76 struct _ValaHashSetIteratorClass {
77 ValaIteratorClass parent_class;
78 };
79
80 struct _ValaHashSetIteratorPrivate {
81 GType g_type;
82 GBoxedCopyFunc g_dup_func;
83 GDestroyNotify g_destroy_func;
84 ValaHashSet* _set;
85 gint _index;
86 ValaHashSetNode* _node;
87 ValaHashSetNode* _next;
88 gint _stamp;
89 };
90
91 static gint ValaHashSet_private_offset;
92 static gpointer vala_hash_set_parent_class = NULL;
93 static gint ValaHashSetIterator_private_offset;
94 static gpointer vala_hash_set_iterator_parent_class = NULL;
95
96 static void vala_hash_set_node_free (ValaHashSetNode * self);
97 #define VALA_HASH_SET_MIN_SIZE 11
98 #define VALA_HASH_SET_MAX_SIZE 13845163
99 static ValaHashSetNode** vala_hash_set_lookup_node (ValaHashSet* self,
100 gconstpointer key);
101 static gboolean vala_hash_set_real_contains (ValaCollection* base,
102 gconstpointer key);
103 static GType vala_hash_set_real_get_element_type (ValaIterable* base);
104 static ValaIterator* vala_hash_set_real_iterator (ValaIterable* base);
105 static ValaHashSetIterator* vala_hash_set_iterator_new (GType g_type,
106 GBoxedCopyFunc g_dup_func,
107 GDestroyNotify g_destroy_func,
108 ValaHashSet* set);
109 static ValaHashSetIterator* vala_hash_set_iterator_construct (GType object_type,
110 GType g_type,
111 GBoxedCopyFunc g_dup_func,
112 GDestroyNotify g_destroy_func,
113 ValaHashSet* set);
114 static GType vala_hash_set_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
115 static gboolean vala_hash_set_real_add (ValaCollection* base,
116 gconstpointer key);
117 static ValaHashSetNode* vala_hash_set_node_new (gpointer k,
118 guint hash);
119 static void vala_hash_set_resize (ValaHashSet* self);
120 static gboolean vala_hash_set_real_remove (ValaCollection* base,
121 gconstpointer key);
122 static void vala_hash_set_real_clear (ValaCollection* base);
123 static inline gboolean vala_hash_set_remove_helper (ValaHashSet* self,
124 gconstpointer key);
125 static void vala_hash_set_node_instance_init (ValaHashSetNode * self);
126 static void vala_hash_set_iterator_set_set (ValaHashSetIterator* self,
127 ValaHashSet* value);
128 static gboolean vala_hash_set_iterator_real_next (ValaIterator* base);
129 static gboolean vala_hash_set_iterator_real_has_next (ValaIterator* base);
130 static gpointer vala_hash_set_iterator_real_get (ValaIterator* base);
131 static void vala_hash_set_iterator_real_remove (ValaIterator* base);
132 static void vala_hash_set_iterator_finalize (ValaIterator * obj);
133 static GType vala_hash_set_iterator_get_type_once (void);
134 static void vala_hash_set_finalize (ValaIterable * obj);
135 static GType vala_hash_set_get_type_once (void);
136 static void _vala_array_destroy (gpointer array,
137 gint array_length,
138 GDestroyNotify destroy_func);
139 static void _vala_array_free (gpointer array,
140 gint array_length,
141 GDestroyNotify destroy_func);
142
143 static inline gpointer
vala_hash_set_get_instance_private(ValaHashSet * self)144 vala_hash_set_get_instance_private (ValaHashSet* self)
145 {
146 return G_STRUCT_MEMBER_P (self, ValaHashSet_private_offset);
147 }
148
149 static gint
vala_hash_set_real_get_size(ValaCollection * base)150 vala_hash_set_real_get_size (ValaCollection* base)
151 {
152 gint result;
153 ValaHashSet* self;
154 self = (ValaHashSet*) base;
155 result = self->priv->_nnodes;
156 return result;
157 }
158
159 void
vala_hash_set_set_hash_func(ValaHashSet * self,GHashFunc value)160 vala_hash_set_set_hash_func (ValaHashSet* self,
161 GHashFunc value)
162 {
163 g_return_if_fail (self != NULL);
164 self->priv->_hash_func = value;
165 }
166
167 void
vala_hash_set_set_equal_func(ValaHashSet * self,GEqualFunc value)168 vala_hash_set_set_equal_func (ValaHashSet* self,
169 GEqualFunc value)
170 {
171 g_return_if_fail (self != NULL);
172 self->priv->_equal_func = value;
173 }
174
175 ValaHashSet*
vala_hash_set_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GHashFunc hash_func,GEqualFunc equal_func)176 vala_hash_set_construct (GType object_type,
177 GType g_type,
178 GBoxedCopyFunc g_dup_func,
179 GDestroyNotify g_destroy_func,
180 GHashFunc hash_func,
181 GEqualFunc equal_func)
182 {
183 ValaHashSet* self = NULL;
184 ValaHashSetNode** _tmp0_;
185 self = (ValaHashSet*) vala_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, (GDestroyNotify) g_destroy_func);
186 self->priv->g_type = g_type;
187 self->priv->g_dup_func = g_dup_func;
188 self->priv->g_destroy_func = g_destroy_func;
189 vala_hash_set_set_hash_func (self, hash_func);
190 vala_hash_set_set_equal_func (self, equal_func);
191 self->priv->_array_size = VALA_HASH_SET_MIN_SIZE;
192 _tmp0_ = g_new0 (ValaHashSetNode*, self->priv->_array_size + 1);
193 self->priv->_nodes = (_vala_array_free (self->priv->_nodes, self->priv->_nodes_length1, (GDestroyNotify) vala_hash_set_node_free), NULL);
194 self->priv->_nodes = _tmp0_;
195 self->priv->_nodes_length1 = self->priv->_array_size;
196 self->priv->__nodes_size_ = self->priv->_nodes_length1;
197 return self;
198 }
199
200 ValaHashSet*
vala_hash_set_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,GHashFunc hash_func,GEqualFunc equal_func)201 vala_hash_set_new (GType g_type,
202 GBoxedCopyFunc g_dup_func,
203 GDestroyNotify g_destroy_func,
204 GHashFunc hash_func,
205 GEqualFunc equal_func)
206 {
207 return vala_hash_set_construct (VALA_TYPE_HASH_SET, g_type, g_dup_func, g_destroy_func, hash_func, equal_func);
208 }
209
210 static ValaHashSetNode**
vala_hash_set_lookup_node(ValaHashSet * self,gconstpointer key)211 vala_hash_set_lookup_node (ValaHashSet* self,
212 gconstpointer key)
213 {
214 guint hash_value = 0U;
215 GHashFunc _tmp0_;
216 ValaHashSetNode** node = NULL;
217 ValaHashSetNode** _tmp1_;
218 gint _tmp1__length1;
219 ValaHashSetNode** _tmp10_;
220 ValaHashSetNode** result = NULL;
221 g_return_val_if_fail (self != NULL, NULL);
222 _tmp0_ = self->priv->_hash_func;
223 hash_value = _tmp0_ (key);
224 _tmp1_ = self->priv->_nodes;
225 _tmp1__length1 = self->priv->_nodes_length1;
226 node = &_tmp1_[hash_value % self->priv->_array_size];
227 while (TRUE) {
228 gboolean _tmp2_ = FALSE;
229 ValaHashSetNode** _tmp3_;
230 ValaHashSetNode** _tmp9_;
231 _tmp3_ = node;
232 if ((*_tmp3_) != NULL) {
233 gboolean _tmp4_ = FALSE;
234 ValaHashSetNode** _tmp5_;
235 _tmp5_ = node;
236 if (hash_value != (*_tmp5_)->key_hash) {
237 _tmp4_ = TRUE;
238 } else {
239 GEqualFunc _tmp6_;
240 ValaHashSetNode** _tmp7_;
241 gconstpointer _tmp8_;
242 _tmp6_ = self->priv->_equal_func;
243 _tmp7_ = node;
244 _tmp8_ = (*_tmp7_)->key;
245 _tmp4_ = !_tmp6_ (_tmp8_, key);
246 }
247 _tmp2_ = _tmp4_;
248 } else {
249 _tmp2_ = FALSE;
250 }
251 if (!_tmp2_) {
252 break;
253 }
254 _tmp9_ = node;
255 node = &(*_tmp9_)->next;
256 }
257 _tmp10_ = node;
258 result = _tmp10_;
259 return result;
260 }
261
262 static gboolean
vala_hash_set_real_contains(ValaCollection * base,gconstpointer key)263 vala_hash_set_real_contains (ValaCollection* base,
264 gconstpointer key)
265 {
266 ValaHashSet * self;
267 ValaHashSetNode** node = NULL;
268 ValaHashSetNode** _tmp0_;
269 gboolean result = FALSE;
270 self = (ValaHashSet*) base;
271 _tmp0_ = vala_hash_set_lookup_node (self, key);
272 node = _tmp0_;
273 result = (*node) != NULL;
274 return result;
275 }
276
277 static GType
vala_hash_set_real_get_element_type(ValaIterable * base)278 vala_hash_set_real_get_element_type (ValaIterable* base)
279 {
280 ValaHashSet * self;
281 GType result = 0UL;
282 self = (ValaHashSet*) base;
283 result = self->priv->g_type;
284 return result;
285 }
286
287 static ValaIterator*
vala_hash_set_real_iterator(ValaIterable * base)288 vala_hash_set_real_iterator (ValaIterable* base)
289 {
290 ValaHashSet * self;
291 ValaHashSetIterator* _tmp0_;
292 ValaIterator* result = NULL;
293 self = (ValaHashSet*) base;
294 _tmp0_ = vala_hash_set_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, (GDestroyNotify) self->priv->g_destroy_func, self);
295 result = (ValaIterator*) _tmp0_;
296 return result;
297 }
298
299 static gboolean
vala_hash_set_real_add(ValaCollection * base,gconstpointer key)300 vala_hash_set_real_add (ValaCollection* base,
301 gconstpointer key)
302 {
303 ValaHashSet * self;
304 ValaHashSetNode** node = NULL;
305 ValaHashSetNode** _tmp0_;
306 ValaHashSetNode** _tmp1_;
307 gboolean result = FALSE;
308 self = (ValaHashSet*) base;
309 _tmp0_ = vala_hash_set_lookup_node (self, key);
310 node = _tmp0_;
311 _tmp1_ = node;
312 if ((*_tmp1_) != NULL) {
313 result = FALSE;
314 return result;
315 } else {
316 guint hash_value = 0U;
317 GHashFunc _tmp2_;
318 ValaHashSetNode** _tmp3_;
319 gpointer _tmp4_;
320 ValaHashSetNode* _tmp5_;
321 gint _tmp6_;
322 gint _tmp7_;
323 _tmp2_ = self->priv->_hash_func;
324 hash_value = _tmp2_ (key);
325 _tmp3_ = node;
326 _tmp4_ = ((key != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) key) : ((gpointer) key);
327 _tmp5_ = vala_hash_set_node_new (_tmp4_, hash_value);
328 *_tmp3_ = _tmp5_;
329 _tmp6_ = self->priv->_nnodes;
330 self->priv->_nnodes = _tmp6_ + 1;
331 vala_hash_set_resize (self);
332 _tmp7_ = self->priv->_stamp;
333 self->priv->_stamp = _tmp7_ + 1;
334 result = TRUE;
335 return result;
336 }
337 }
338
339 static gboolean
vala_hash_set_real_remove(ValaCollection * base,gconstpointer key)340 vala_hash_set_real_remove (ValaCollection* base,
341 gconstpointer key)
342 {
343 ValaHashSet * self;
344 ValaHashSetNode** node = NULL;
345 ValaHashSetNode** _tmp0_;
346 ValaHashSetNode** _tmp1_;
347 gboolean result = FALSE;
348 self = (ValaHashSet*) base;
349 _tmp0_ = vala_hash_set_lookup_node (self, key);
350 node = _tmp0_;
351 _tmp1_ = node;
352 if ((*_tmp1_) != NULL) {
353 ValaHashSetNode* next = NULL;
354 ValaHashSetNode** _tmp2_;
355 ValaHashSetNode* _tmp3_;
356 ValaHashSetNode** _tmp4_;
357 ValaHashSetNode** _tmp5_;
358 ValaHashSetNode** _tmp6_;
359 ValaHashSetNode* _tmp7_;
360 gint _tmp8_;
361 gint _tmp9_;
362 _tmp2_ = node;
363 _tmp3_ = (*_tmp2_)->next;
364 (*_tmp2_)->next = NULL;
365 next = _tmp3_;
366 _tmp4_ = node;
367 (((*_tmp4_)->key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : ((*_tmp4_)->key = (self->priv->g_destroy_func ((*_tmp4_)->key), NULL));
368 (*_tmp4_)->key = NULL;
369 _tmp5_ = node;
370 vala_hash_set_node_free (*_tmp5_);
371 _tmp6_ = node;
372 _tmp7_ = next;
373 next = NULL;
374 *_tmp6_ = _tmp7_;
375 _tmp8_ = self->priv->_nnodes;
376 self->priv->_nnodes = _tmp8_ - 1;
377 vala_hash_set_resize (self);
378 _tmp9_ = self->priv->_stamp;
379 self->priv->_stamp = _tmp9_ + 1;
380 result = TRUE;
381 _vala_hash_set_node_free0 (next);
382 return result;
383 }
384 result = FALSE;
385 return result;
386 }
387
388 static void
vala_hash_set_real_clear(ValaCollection * base)389 vala_hash_set_real_clear (ValaCollection* base)
390 {
391 ValaHashSet * self;
392 self = (ValaHashSet*) base;
393 {
394 gint i = 0;
395 i = 0;
396 {
397 gboolean _tmp0_ = FALSE;
398 _tmp0_ = TRUE;
399 while (TRUE) {
400 ValaHashSetNode* node = NULL;
401 ValaHashSetNode** _tmp2_;
402 gint _tmp2__length1;
403 ValaHashSetNode* _tmp3_;
404 if (!_tmp0_) {
405 gint _tmp1_;
406 _tmp1_ = i;
407 i = _tmp1_ + 1;
408 }
409 _tmp0_ = FALSE;
410 if (!(i < self->priv->_array_size)) {
411 break;
412 }
413 _tmp2_ = self->priv->_nodes;
414 _tmp2__length1 = self->priv->_nodes_length1;
415 _tmp3_ = _tmp2_[i];
416 _tmp2_[i] = NULL;
417 node = _tmp3_;
418 while (TRUE) {
419 ValaHashSetNode* _tmp4_;
420 ValaHashSetNode* next = NULL;
421 ValaHashSetNode* _tmp5_;
422 ValaHashSetNode* _tmp6_;
423 ValaHashSetNode* _tmp7_;
424 ValaHashSetNode* _tmp8_;
425 _tmp4_ = node;
426 if (!(_tmp4_ != NULL)) {
427 break;
428 }
429 _tmp5_ = node;
430 _tmp6_ = _tmp5_->next;
431 _tmp5_->next = NULL;
432 next = _tmp6_;
433 _tmp7_ = node;
434 ((_tmp7_->key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (_tmp7_->key = (self->priv->g_destroy_func (_tmp7_->key), NULL));
435 _tmp7_->key = NULL;
436 _tmp8_ = next;
437 next = NULL;
438 _vala_hash_set_node_free0 (node);
439 node = _tmp8_;
440 _vala_hash_set_node_free0 (next);
441 }
442 _vala_hash_set_node_free0 (node);
443 }
444 }
445 }
446 self->priv->_nnodes = 0;
447 vala_hash_set_resize (self);
448 }
449
450 static inline gboolean
vala_hash_set_remove_helper(ValaHashSet * self,gconstpointer key)451 vala_hash_set_remove_helper (ValaHashSet* self,
452 gconstpointer key)
453 {
454 ValaHashSetNode** node = NULL;
455 ValaHashSetNode** _tmp0_;
456 ValaHashSetNode** _tmp1_;
457 gboolean result = FALSE;
458 g_return_val_if_fail (self != NULL, FALSE);
459 _tmp0_ = vala_hash_set_lookup_node (self, key);
460 node = _tmp0_;
461 _tmp1_ = node;
462 if ((*_tmp1_) != NULL) {
463 ValaHashSetNode** _tmp2_;
464 ValaHashSetNode* next = NULL;
465 ValaHashSetNode** _tmp3_;
466 ValaHashSetNode* _tmp4_;
467 ValaHashSetNode** _tmp5_;
468 ValaHashSetNode** _tmp6_;
469 ValaHashSetNode** _tmp7_;
470 ValaHashSetNode* _tmp8_;
471 gint _tmp9_;
472 gint _tmp10_;
473 _tmp2_ = node;
474 _vala_assert ((*_tmp2_) != NULL, "*node != null");
475 _tmp3_ = node;
476 _tmp4_ = (*_tmp3_)->next;
477 (*_tmp3_)->next = NULL;
478 next = _tmp4_;
479 _tmp5_ = node;
480 (((*_tmp5_)->key == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : ((*_tmp5_)->key = (self->priv->g_destroy_func ((*_tmp5_)->key), NULL));
481 (*_tmp5_)->key = NULL;
482 _tmp6_ = node;
483 vala_hash_set_node_free (*_tmp6_);
484 _tmp7_ = node;
485 _tmp8_ = next;
486 next = NULL;
487 *_tmp7_ = _tmp8_;
488 _tmp9_ = self->priv->_nnodes;
489 self->priv->_nnodes = _tmp9_ - 1;
490 _tmp10_ = self->priv->_stamp;
491 self->priv->_stamp = _tmp10_ + 1;
492 result = TRUE;
493 _vala_hash_set_node_free0 (next);
494 return result;
495 }
496 result = FALSE;
497 return result;
498 }
499
500 static void
vala_hash_set_resize(ValaHashSet * self)501 vala_hash_set_resize (ValaHashSet* self)
502 {
503 gboolean _tmp0_ = FALSE;
504 gboolean _tmp1_ = FALSE;
505 g_return_if_fail (self != NULL);
506 if (self->priv->_array_size >= (3 * self->priv->_nnodes)) {
507 _tmp1_ = self->priv->_array_size >= VALA_HASH_SET_MIN_SIZE;
508 } else {
509 _tmp1_ = FALSE;
510 }
511 if (_tmp1_) {
512 _tmp0_ = TRUE;
513 } else {
514 gboolean _tmp2_ = FALSE;
515 if ((3 * self->priv->_array_size) <= self->priv->_nnodes) {
516 _tmp2_ = self->priv->_array_size < VALA_HASH_SET_MAX_SIZE;
517 } else {
518 _tmp2_ = FALSE;
519 }
520 _tmp0_ = _tmp2_;
521 }
522 if (_tmp0_) {
523 gint new_array_size = 0;
524 ValaHashSetNode** new_nodes = NULL;
525 ValaHashSetNode** _tmp3_;
526 gint new_nodes_length1;
527 gint _new_nodes_size_;
528 ValaHashSetNode** _tmp19_;
529 gint _tmp19__length1;
530 new_array_size = (gint) g_spaced_primes_closest ((guint) self->priv->_nnodes);
531 new_array_size = CLAMP (new_array_size, VALA_HASH_SET_MIN_SIZE, VALA_HASH_SET_MAX_SIZE);
532 _tmp3_ = g_new0 (ValaHashSetNode*, new_array_size + 1);
533 new_nodes = _tmp3_;
534 new_nodes_length1 = new_array_size;
535 _new_nodes_size_ = new_nodes_length1;
536 {
537 gint i = 0;
538 i = 0;
539 {
540 gboolean _tmp4_ = FALSE;
541 _tmp4_ = TRUE;
542 while (TRUE) {
543 ValaHashSetNode* node = NULL;
544 ValaHashSetNode* next = NULL;
545 if (!_tmp4_) {
546 gint _tmp5_;
547 _tmp5_ = i;
548 i = _tmp5_ + 1;
549 }
550 _tmp4_ = FALSE;
551 if (!(i < self->priv->_array_size)) {
552 break;
553 }
554 next = NULL;
555 {
556 ValaHashSetNode** _tmp6_;
557 gint _tmp6__length1;
558 ValaHashSetNode* _tmp7_;
559 gboolean _tmp8_ = FALSE;
560 _tmp6_ = self->priv->_nodes;
561 _tmp6__length1 = self->priv->_nodes_length1;
562 _tmp7_ = _tmp6_[i];
563 _tmp6_[i] = NULL;
564 _vala_hash_set_node_free0 (node);
565 node = _tmp7_;
566 _tmp8_ = TRUE;
567 while (TRUE) {
568 ValaHashSetNode* _tmp10_;
569 ValaHashSetNode* _tmp11_;
570 ValaHashSetNode* _tmp12_;
571 guint hash_val = 0U;
572 ValaHashSetNode* _tmp13_;
573 ValaHashSetNode* _tmp14_;
574 ValaHashSetNode** _tmp15_;
575 gint _tmp15__length1;
576 ValaHashSetNode* _tmp16_;
577 ValaHashSetNode** _tmp17_;
578 gint _tmp17__length1;
579 ValaHashSetNode* _tmp18_;
580 if (!_tmp8_) {
581 ValaHashSetNode* _tmp9_;
582 _tmp9_ = next;
583 next = NULL;
584 _vala_hash_set_node_free0 (node);
585 node = _tmp9_;
586 }
587 _tmp8_ = FALSE;
588 _tmp10_ = node;
589 if (!(_tmp10_ != NULL)) {
590 break;
591 }
592 _tmp11_ = node;
593 _tmp12_ = _tmp11_->next;
594 _tmp11_->next = NULL;
595 _vala_hash_set_node_free0 (next);
596 next = _tmp12_;
597 _tmp13_ = node;
598 hash_val = _tmp13_->key_hash % new_array_size;
599 _tmp14_ = node;
600 _tmp15_ = new_nodes;
601 _tmp15__length1 = new_nodes_length1;
602 _tmp16_ = _tmp15_[hash_val];
603 _tmp15_[hash_val] = NULL;
604 _vala_hash_set_node_free0 (_tmp14_->next);
605 _tmp14_->next = _tmp16_;
606 _tmp17_ = new_nodes;
607 _tmp17__length1 = new_nodes_length1;
608 _tmp18_ = node;
609 node = NULL;
610 _vala_hash_set_node_free0 (_tmp17_[hash_val]);
611 _tmp17_[hash_val] = _tmp18_;
612 }
613 }
614 _vala_hash_set_node_free0 (next);
615 _vala_hash_set_node_free0 (node);
616 }
617 }
618 }
619 _tmp19_ = new_nodes;
620 _tmp19__length1 = new_nodes_length1;
621 new_nodes = NULL;
622 new_nodes_length1 = 0;
623 self->priv->_nodes = (_vala_array_free (self->priv->_nodes, self->priv->_nodes_length1, (GDestroyNotify) vala_hash_set_node_free), NULL);
624 self->priv->_nodes = _tmp19_;
625 self->priv->_nodes_length1 = _tmp19__length1;
626 self->priv->__nodes_size_ = self->priv->_nodes_length1;
627 self->priv->_array_size = new_array_size;
628 new_nodes = (_vala_array_free (new_nodes, new_nodes_length1, (GDestroyNotify) vala_hash_set_node_free), NULL);
629 }
630 }
631
632 static ValaHashSetNode*
vala_hash_set_node_new(gpointer k,guint hash)633 vala_hash_set_node_new (gpointer k,
634 guint hash)
635 {
636 ValaHashSetNode* self;
637 gpointer _tmp0_;
638 self = g_slice_new0 (ValaHashSetNode);
639 vala_hash_set_node_instance_init (self);
640 _tmp0_ = k;
641 k = NULL;
642 self->key = _tmp0_;
643 self->key_hash = hash;
644 return self;
645 }
646
647 static void
vala_hash_set_node_instance_init(ValaHashSetNode * self)648 vala_hash_set_node_instance_init (ValaHashSetNode * self)
649 {
650 }
651
652 static void
vala_hash_set_node_free(ValaHashSetNode * self)653 vala_hash_set_node_free (ValaHashSetNode * self)
654 {
655 _vala_hash_set_node_free0 (self->next);
656 g_slice_free (ValaHashSetNode, self);
657 }
658
659 static inline gpointer
vala_hash_set_iterator_get_instance_private(ValaHashSetIterator * self)660 vala_hash_set_iterator_get_instance_private (ValaHashSetIterator* self)
661 {
662 return G_STRUCT_MEMBER_P (self, ValaHashSetIterator_private_offset);
663 }
664
665 static gpointer
_vala_iterable_ref0(gpointer self)666 _vala_iterable_ref0 (gpointer self)
667 {
668 return self ? vala_iterable_ref (self) : NULL;
669 }
670
671 static void
vala_hash_set_iterator_set_set(ValaHashSetIterator * self,ValaHashSet * value)672 vala_hash_set_iterator_set_set (ValaHashSetIterator* self,
673 ValaHashSet* value)
674 {
675 ValaHashSet* _tmp0_;
676 ValaHashSet* _tmp1_;
677 g_return_if_fail (self != NULL);
678 _tmp0_ = _vala_iterable_ref0 (value);
679 _vala_iterable_unref0 (self->priv->_set);
680 self->priv->_set = _tmp0_;
681 _tmp1_ = self->priv->_set;
682 self->priv->_stamp = _tmp1_->priv->_stamp;
683 }
684
685 static ValaHashSetIterator*
vala_hash_set_iterator_construct(GType object_type,GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,ValaHashSet * set)686 vala_hash_set_iterator_construct (GType object_type,
687 GType g_type,
688 GBoxedCopyFunc g_dup_func,
689 GDestroyNotify g_destroy_func,
690 ValaHashSet* set)
691 {
692 ValaHashSetIterator* self = NULL;
693 g_return_val_if_fail (set != NULL, NULL);
694 self = (ValaHashSetIterator*) vala_iterator_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, (GDestroyNotify) g_destroy_func);
695 self->priv->g_type = g_type;
696 self->priv->g_dup_func = g_dup_func;
697 self->priv->g_destroy_func = g_destroy_func;
698 vala_hash_set_iterator_set_set (self, set);
699 return self;
700 }
701
702 static ValaHashSetIterator*
vala_hash_set_iterator_new(GType g_type,GBoxedCopyFunc g_dup_func,GDestroyNotify g_destroy_func,ValaHashSet * set)703 vala_hash_set_iterator_new (GType g_type,
704 GBoxedCopyFunc g_dup_func,
705 GDestroyNotify g_destroy_func,
706 ValaHashSet* set)
707 {
708 return vala_hash_set_iterator_construct (VALA_HASH_SET_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, set);
709 }
710
711 static gboolean
vala_hash_set_iterator_real_next(ValaIterator * base)712 vala_hash_set_iterator_real_next (ValaIterator* base)
713 {
714 ValaHashSetIterator * self;
715 ValaHashSet* _tmp0_;
716 ValaHashSetNode* _tmp1_;
717 ValaHashSetNode* _tmp2_;
718 gboolean result = FALSE;
719 self = (ValaHashSetIterator*) base;
720 _tmp0_ = self->priv->_set;
721 _vala_assert (self->priv->_stamp == _tmp0_->priv->_stamp, "_stamp == _set._stamp");
722 if (!vala_iterator_has_next ((ValaIterator*) self)) {
723 result = FALSE;
724 return result;
725 }
726 _tmp1_ = self->priv->_next;
727 self->priv->_node = _tmp1_;
728 self->priv->_next = NULL;
729 _tmp2_ = self->priv->_node;
730 result = _tmp2_ != NULL;
731 return result;
732 }
733
734 static gboolean
vala_hash_set_iterator_real_has_next(ValaIterator * base)735 vala_hash_set_iterator_real_has_next (ValaIterator* base)
736 {
737 ValaHashSetIterator * self;
738 ValaHashSet* _tmp0_;
739 ValaHashSetNode* _tmp1_;
740 ValaHashSetNode* _tmp13_;
741 gboolean result = FALSE;
742 self = (ValaHashSetIterator*) base;
743 _tmp0_ = self->priv->_set;
744 _vala_assert (self->priv->_stamp == _tmp0_->priv->_stamp, "_stamp == _set._stamp");
745 _tmp1_ = self->priv->_next;
746 if (_tmp1_ == NULL) {
747 ValaHashSetNode* _tmp2_;
748 ValaHashSetNode* _tmp3_;
749 _tmp2_ = self->priv->_node;
750 self->priv->_next = _tmp2_;
751 _tmp3_ = self->priv->_next;
752 if (_tmp3_ != NULL) {
753 ValaHashSetNode* _tmp4_;
754 ValaHashSetNode* _tmp5_;
755 _tmp4_ = self->priv->_next;
756 _tmp5_ = _tmp4_->next;
757 self->priv->_next = _tmp5_;
758 }
759 while (TRUE) {
760 gboolean _tmp6_ = FALSE;
761 ValaHashSetNode* _tmp7_;
762 gint _tmp9_;
763 ValaHashSet* _tmp10_;
764 ValaHashSetNode** _tmp11_;
765 gint _tmp11__length1;
766 ValaHashSetNode* _tmp12_;
767 _tmp7_ = self->priv->_next;
768 if (_tmp7_ == NULL) {
769 ValaHashSet* _tmp8_;
770 _tmp8_ = self->priv->_set;
771 _tmp6_ = (self->priv->_index + 1) < _tmp8_->priv->_array_size;
772 } else {
773 _tmp6_ = FALSE;
774 }
775 if (!_tmp6_) {
776 break;
777 }
778 _tmp9_ = self->priv->_index;
779 self->priv->_index = _tmp9_ + 1;
780 _tmp10_ = self->priv->_set;
781 _tmp11_ = _tmp10_->priv->_nodes;
782 _tmp11__length1 = _tmp10_->priv->_nodes_length1;
783 _tmp12_ = _tmp11_[self->priv->_index];
784 self->priv->_next = _tmp12_;
785 }
786 }
787 _tmp13_ = self->priv->_next;
788 result = _tmp13_ != NULL;
789 return result;
790 }
791
792 static gpointer
vala_hash_set_iterator_real_get(ValaIterator * base)793 vala_hash_set_iterator_real_get (ValaIterator* base)
794 {
795 ValaHashSetIterator * self;
796 ValaHashSet* _tmp0_;
797 ValaHashSetNode* _tmp1_;
798 ValaHashSetNode* _tmp2_;
799 gconstpointer _tmp3_;
800 gpointer _tmp4_;
801 gpointer result = NULL;
802 self = (ValaHashSetIterator*) base;
803 _tmp0_ = self->priv->_set;
804 _vala_assert (self->priv->_stamp == _tmp0_->priv->_stamp, "_stamp == _set._stamp");
805 _tmp1_ = self->priv->_node;
806 _vala_assert (_tmp1_ != NULL, "_node != null");
807 _tmp2_ = self->priv->_node;
808 _tmp3_ = _tmp2_->key;
809 _tmp4_ = ((_tmp3_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp3_) : ((gpointer) _tmp3_);
810 result = _tmp4_;
811 return result;
812 }
813
814 static void
vala_hash_set_iterator_real_remove(ValaIterator * base)815 vala_hash_set_iterator_real_remove (ValaIterator* base)
816 {
817 ValaHashSetIterator * self;
818 ValaHashSet* _tmp0_;
819 ValaHashSetNode* _tmp1_;
820 ValaHashSet* _tmp2_;
821 ValaHashSetNode* _tmp3_;
822 gconstpointer _tmp4_;
823 ValaHashSet* _tmp5_;
824 self = (ValaHashSetIterator*) base;
825 _tmp0_ = self->priv->_set;
826 _vala_assert (self->priv->_stamp == _tmp0_->priv->_stamp, "_stamp == _set._stamp");
827 _tmp1_ = self->priv->_node;
828 _vala_assert (_tmp1_ != NULL, "_node != null");
829 vala_iterator_has_next ((ValaIterator*) self);
830 _tmp2_ = self->priv->_set;
831 _tmp3_ = self->priv->_node;
832 _tmp4_ = _tmp3_->key;
833 vala_hash_set_remove_helper (_tmp2_, _tmp4_);
834 self->priv->_node = NULL;
835 _tmp5_ = self->priv->_set;
836 self->priv->_stamp = _tmp5_->priv->_stamp;
837 }
838
839 static gboolean
vala_hash_set_iterator_real_get_valid(ValaIterator * base)840 vala_hash_set_iterator_real_get_valid (ValaIterator* base)
841 {
842 gboolean result;
843 ValaHashSetIterator* self;
844 ValaHashSetNode* _tmp0_;
845 self = (ValaHashSetIterator*) base;
846 _tmp0_ = self->priv->_node;
847 result = _tmp0_ != NULL;
848 return result;
849 }
850
851 static void
vala_hash_set_iterator_class_init(ValaHashSetIteratorClass * klass,gpointer klass_data)852 vala_hash_set_iterator_class_init (ValaHashSetIteratorClass * klass,
853 gpointer klass_data)
854 {
855 vala_hash_set_iterator_parent_class = g_type_class_peek_parent (klass);
856 ((ValaIteratorClass *) klass)->finalize = vala_hash_set_iterator_finalize;
857 g_type_class_adjust_private_offset (klass, &ValaHashSetIterator_private_offset);
858 ((ValaIteratorClass *) klass)->next = (gboolean (*) (ValaIterator*)) vala_hash_set_iterator_real_next;
859 ((ValaIteratorClass *) klass)->has_next = (gboolean (*) (ValaIterator*)) vala_hash_set_iterator_real_has_next;
860 ((ValaIteratorClass *) klass)->get = (gpointer (*) (ValaIterator*)) vala_hash_set_iterator_real_get;
861 ((ValaIteratorClass *) klass)->remove = (void (*) (ValaIterator*)) vala_hash_set_iterator_real_remove;
862 VALA_ITERATOR_CLASS (klass)->get_valid = vala_hash_set_iterator_real_get_valid;
863 }
864
865 static void
vala_hash_set_iterator_instance_init(ValaHashSetIterator * self,gpointer klass)866 vala_hash_set_iterator_instance_init (ValaHashSetIterator * self,
867 gpointer klass)
868 {
869 self->priv = vala_hash_set_iterator_get_instance_private (self);
870 self->priv->_index = -1;
871 self->priv->_stamp = 0;
872 }
873
874 static void
vala_hash_set_iterator_finalize(ValaIterator * obj)875 vala_hash_set_iterator_finalize (ValaIterator * obj)
876 {
877 ValaHashSetIterator * self;
878 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_HASH_SET_TYPE_ITERATOR, ValaHashSetIterator);
879 _vala_iterable_unref0 (self->priv->_set);
880 VALA_ITERATOR_CLASS (vala_hash_set_iterator_parent_class)->finalize (obj);
881 }
882
883 static GType
vala_hash_set_iterator_get_type_once(void)884 vala_hash_set_iterator_get_type_once (void)
885 {
886 static const GTypeInfo g_define_type_info = { sizeof (ValaHashSetIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_hash_set_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaHashSetIterator), 0, (GInstanceInitFunc) vala_hash_set_iterator_instance_init, NULL };
887 GType vala_hash_set_iterator_type_id;
888 vala_hash_set_iterator_type_id = g_type_register_static (VALA_TYPE_ITERATOR, "ValaHashSetIterator", &g_define_type_info, 0);
889 ValaHashSetIterator_private_offset = g_type_add_instance_private (vala_hash_set_iterator_type_id, sizeof (ValaHashSetIteratorPrivate));
890 return vala_hash_set_iterator_type_id;
891 }
892
893 static GType
vala_hash_set_iterator_get_type(void)894 vala_hash_set_iterator_get_type (void)
895 {
896 static volatile gsize vala_hash_set_iterator_type_id__volatile = 0;
897 if (g_once_init_enter (&vala_hash_set_iterator_type_id__volatile)) {
898 GType vala_hash_set_iterator_type_id;
899 vala_hash_set_iterator_type_id = vala_hash_set_iterator_get_type_once ();
900 g_once_init_leave (&vala_hash_set_iterator_type_id__volatile, vala_hash_set_iterator_type_id);
901 }
902 return vala_hash_set_iterator_type_id__volatile;
903 }
904
905 static void
vala_hash_set_class_init(ValaHashSetClass * klass,gpointer klass_data)906 vala_hash_set_class_init (ValaHashSetClass * klass,
907 gpointer klass_data)
908 {
909 vala_hash_set_parent_class = g_type_class_peek_parent (klass);
910 ((ValaIterableClass *) klass)->finalize = vala_hash_set_finalize;
911 g_type_class_adjust_private_offset (klass, &ValaHashSet_private_offset);
912 ((ValaCollectionClass *) klass)->contains = (gboolean (*) (ValaCollection*, gconstpointer)) vala_hash_set_real_contains;
913 ((ValaIterableClass *) klass)->get_element_type = (GType (*) (ValaIterable*)) vala_hash_set_real_get_element_type;
914 ((ValaIterableClass *) klass)->iterator = (ValaIterator* (*) (ValaIterable*)) vala_hash_set_real_iterator;
915 ((ValaCollectionClass *) klass)->add = (gboolean (*) (ValaCollection*, gconstpointer)) vala_hash_set_real_add;
916 ((ValaCollectionClass *) klass)->remove = (gboolean (*) (ValaCollection*, gconstpointer)) vala_hash_set_real_remove;
917 ((ValaCollectionClass *) klass)->clear = (void (*) (ValaCollection*)) vala_hash_set_real_clear;
918 VALA_COLLECTION_CLASS (klass)->get_size = vala_hash_set_real_get_size;
919 }
920
921 static void
vala_hash_set_instance_init(ValaHashSet * self,gpointer klass)922 vala_hash_set_instance_init (ValaHashSet * self,
923 gpointer klass)
924 {
925 self->priv = vala_hash_set_get_instance_private (self);
926 self->priv->_stamp = 0;
927 }
928
929 static void
vala_hash_set_finalize(ValaIterable * obj)930 vala_hash_set_finalize (ValaIterable * obj)
931 {
932 ValaHashSet * self;
933 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_HASH_SET, ValaHashSet);
934 vala_collection_clear ((ValaCollection*) self);
935 self->priv->_nodes = (_vala_array_free (self->priv->_nodes, self->priv->_nodes_length1, (GDestroyNotify) vala_hash_set_node_free), NULL);
936 VALA_ITERABLE_CLASS (vala_hash_set_parent_class)->finalize (obj);
937 }
938
939 /**
940 * Hashtable implementation of the Set interface.
941 */
942 static GType
vala_hash_set_get_type_once(void)943 vala_hash_set_get_type_once (void)
944 {
945 static const GTypeInfo g_define_type_info = { sizeof (ValaHashSetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_hash_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaHashSet), 0, (GInstanceInitFunc) vala_hash_set_instance_init, NULL };
946 GType vala_hash_set_type_id;
947 vala_hash_set_type_id = g_type_register_static (VALA_TYPE_SET, "ValaHashSet", &g_define_type_info, 0);
948 ValaHashSet_private_offset = g_type_add_instance_private (vala_hash_set_type_id, sizeof (ValaHashSetPrivate));
949 return vala_hash_set_type_id;
950 }
951
952 GType
vala_hash_set_get_type(void)953 vala_hash_set_get_type (void)
954 {
955 static volatile gsize vala_hash_set_type_id__volatile = 0;
956 if (g_once_init_enter (&vala_hash_set_type_id__volatile)) {
957 GType vala_hash_set_type_id;
958 vala_hash_set_type_id = vala_hash_set_get_type_once ();
959 g_once_init_leave (&vala_hash_set_type_id__volatile, vala_hash_set_type_id);
960 }
961 return vala_hash_set_type_id__volatile;
962 }
963
964 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)965 _vala_array_destroy (gpointer array,
966 gint array_length,
967 GDestroyNotify destroy_func)
968 {
969 if ((array != NULL) && (destroy_func != NULL)) {
970 gint i;
971 for (i = 0; i < array_length; i = i + 1) {
972 if (((gpointer*) array)[i] != NULL) {
973 destroy_func (((gpointer*) array)[i]);
974 }
975 }
976 }
977 }
978
979 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)980 _vala_array_free (gpointer array,
981 gint array_length,
982 GDestroyNotify destroy_func)
983 {
984 _vala_array_destroy (array, array_length, destroy_func);
985 g_free (array);
986 }
987
988