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