Navigation

← Previous Changeset
Next Changeset →

Changeset 5550

Timestamp:

06/01/08 22:21:40 (4 months ago)

Author:

morris

Message:

Copy wi-hash implementation to new name wi-dictionary

Files:

libwired/trunk/libwired/base/wi-base.c (modified) (2 diffs)
libwired/trunk/libwired/base/wi-private.h (modified) (4 diffs)
libwired/trunk/libwired/collections/wi-dictionary.c (copied) (copied from libwired/trunk/libwired/collections/wi-hash.c) (34 diffs)
libwired/trunk/libwired/collections/wi-dictionary.h (copied) (copied from libwired/trunk/libwired/collections/wi-hash.h) (2 diffs)
libwired/trunk/libwired/wired.h (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

libwired/trunk/libwired/base/wi-base.c

r5417	r5550
65	65	wi_data_register();
66	66	wi_date_register();
	67	wi_dictionary_register();
67	68	wi_enumerator_register();
68	69	wi_error_register();
…	…
116	117
117	118	wi_array_initialize();
	119	wi_dictionary_initialize();
118	120	wi_hash_initialize();
119	121	wi_set_initialize();

libwired/trunk/libwired/base/wi-private.h

r5547	r5550
34	34	#include <wired/wi-array.h>
35	35	#include <wired/wi-base.h>
	36	#include <wired/wi-dictionary.h>
36	37	#include <wired/wi-enumerator.h>
37	38	#include <wired/wi-error.h>
…	…
62	63	WI_EXPORT void wi_data_register(void);
63	64	WI_EXPORT void wi_date_register(void);
	65	WI_EXPORT void wi_dictionary_register(void);
64	66	WI_EXPORT void wi_enumerator_register(void);
65	67	WI_EXPORT void wi_error_register(void);
…	…
98	100	WI_EXPORT void wi_data_initialize(void);
99	101	WI_EXPORT void wi_date_initialize(void);
	102	WI_EXPORT void wi_dictionary_initialize(void);
100	103	WI_EXPORT void wi_enumerator_initialize(void);
101	104	WI_EXPORT void wi_error_initialize(void);
…	…
145	148	WI_EXPORT void * wi_enumerator_hash_key_enumerator(wi_runtime_instance_t , wi_enumerator_context_t );
146	149	WI_EXPORT void * wi_enumerator_hash_data_enumerator(wi_runtime_instance_t , wi_enumerator_context_t );
	150	WI_EXPORT void * wi_enumerator_dictionary_key_enumerator(wi_runtime_instance_t , wi_enumerator_context_t );
	151	WI_EXPORT void * wi_enumerator_dictionary_data_enumerator(wi_runtime_instance_t , wi_enumerator_context_t );
147	152	WI_EXPORT void * wi_enumerator_set_data_enumerator(wi_runtime_instance_t , wi_enumerator_context_t );
148	153

libwired/trunk/libwired/collections/wi-dictionary.c

r5549	r5550
36	36	#include <wired/wi-array.h>
37	37	#include <wired/wi-assert.h>
38		#include <wired/wi-~~hash~~.h>
	38	#include <wired/wi-dictionary.h>
39	39	#include <wired/wi-lock.h>
40	40	#include <wired/wi-macros.h>
…	…
45	45	#include <wired/wi-system.h>
46	46
47		#define _WI_~~HASH~~_MIN_COUNT 11
48		#define _WI_~~HASH~~_MAX_COUNT 16777213
49
50		#define _WI_~~HASH_CHECK_RESIZE(hash)~~ \
51		WI_STMT_START \
52		if((~~hash->buckets_count >= 3 * hash->key_count &&~~ \
53		~~hash->buckets_count > hash->min_count) \|\|~~ \
54		(~~hash->key_count >= 3 * hash->buckets_count &&~~ \
55		~~hash->buckets_count < _WI_HASH_MAX_COUNT))~~ \
56		_wi_~~hash_resize(hash);~~ \
	47	#define _WI_DICTIONARY_MIN_COUNT 11
	48	#define _WI_DICTIONARY_MAX_COUNT 16777213
	49
	50	#define _WI_DICTIONARY_CHECK_RESIZE(dictionary) \
	51	WI_STMT_START \
	52	if((dictionary->buckets_count >= 3 * dictionary->key_count && \
	53	dictionary->buckets_count > dictionary->min_count) \|\| \
	54	(dictionary->key_count >= 3 * dictionary->buckets_count && \
	55	dictionary->buckets_count < _WI_DICTIONARY_MAX_COUNT)) \
	56	_wi_dictionary_resize(dictionary); \
57	57	WI_STMT_END
58	58
59		#define _WI_~~HASH_KEY_RETAIN(hash, key)~~ \
60		((~~hash)->key_callbacks.retain~~ \
61		? (*(~~hash)->key_callbacks.retain)((key))~~ \
	59	#define _WI_DICTIONARY_KEY_RETAIN(dictionary, key) \
	60	((dictionary)->key_callbacks.retain \
	61	? (*(dictionary)->key_callbacks.retain)((key)) \
62	62	: (key))
63	63
64		#define _WI_~~HASH_KEY_RELEASE(hash, key)~~ \
65		WI_STMT_START \
66		if((~~hash)->key_callbacks.release)~~ \
67		(*(~~hash)->key_callbacks.release)((key));~~ \
	64	#define _WI_DICTIONARY_KEY_RELEASE(dictionary, key) \
	65	WI_STMT_START \
	66	if((dictionary)->key_callbacks.release) \
	67	(*(dictionary)->key_callbacks.release)((key)); \
68	68	WI_STMT_END
69	69
70		#define _WI_~~HASH_KEY_HASH(hash, key)~~ \
71		((~~hash~~)->key_callbacks.hash \
72		? (*(~~hash~~)->key_callbacks.hash)((key)) \
	70	#define _WI_DICTIONARY_KEY_HASH(dictionary, key) \
	71	((dictionary)->key_callbacks.hash \
	72	? (*(dictionary)->key_callbacks.hash)((key)) \
73	73	: wi_hash_pointer((key)))
74	74
75		#define _WI_~~HASH_KEY_IS_EQUAL(hash, key1, key2)~~ \
76		(((~~hash~~)->key_callbacks.is_equal && \
77		(*(~~hash~~)->key_callbacks.is_equal)((key1), (key2))) \|\| \
78		(!(~~hash)->key_callbacks.is_equal &&~~ \
	75	#define _WI_DICTIONARY_KEY_IS_EQUAL(dictionary, key1, key2) \
	76	(((dictionary)->key_callbacks.is_equal && \
	77	(*(dictionary)->key_callbacks.is_equal)((key1), (key2))) \|\| \
	78	(!(dictionary)->key_callbacks.is_equal && \
79	79	(key1) == (key2)))
80	80
81		#define _WI_~~HASH_VALUE_RETAIN(hash, value)~~ \
82		((~~hash~~)->value_callbacks.retain \
83		? (*(~~hash)->value_callbacks.retain)((value))~~ \
	81	#define _WI_DICTIONARY_VALUE_RETAIN(dictionary, value) \
	82	((dictionary)->value_callbacks.retain \
	83	? (*(dictionary)->value_callbacks.retain)((value)) \
84	84	: (value))
85	85
86		#define _WI_~~HASH_VALUE_RELEASE(hash, value)~~ \
87		WI_STMT_START \
88		if((~~hash~~)->value_callbacks.release) \
89		(*(~~hash)->value_callbacks.release)((value));~~ \
	86	#define _WI_DICTIONARY_VALUE_RELEASE(dictionary, value) \
	87	WI_STMT_START \
	88	if((dictionary)->value_callbacks.release) \
	89	(*(dictionary)->value_callbacks.release)((value)); \
90	90	WI_STMT_END
91	91
92		#define _WI_~~HASH_VALUE_IS_EQUAL(hash, value1, value2)~~ \
93		(((~~hash)->value_callbacks.is_equal &&~~ \
94		(*(~~hash)->value_callbacks.is_equal)((value1), (value2))) \|\|~~ \
95		(!(~~hash~~)->value_callbacks.is_equal && \
	92	#define _WI_DICTIONARY_VALUE_IS_EQUAL(dictionary, value1, value2) \
	93	(((dictionary)->value_callbacks.is_equal && \
	94	(*(dictionary)->value_callbacks.is_equal)((value1), (value2))) \|\| \
	95	(!(dictionary)->value_callbacks.is_equal && \
96	96	(value1) == (value2)))
97	97
98	98
99		struct _wi_~~hash~~_bucket {
	99	struct _wi_dictionary_bucket {
100	100	void *key;
101	101	void *data;
102	102
103		struct _wi_~~hash_bucket~~ next, link;
	103	struct _wi_dictionary_bucket next, link;
104	104	};
105		typedef struct _wi_~~hash_bucket _wi_hash~~_bucket_t;
106
107
108		struct _wi_~~hash~~ {
	105	typedef struct _wi_dictionary_bucket _wi_dictionary_bucket_t;
	106
	107
	108	struct _wi_dictionary {
109	109	wi_runtime_base_t base;
110	110
111		wi_~~hash_key_callbacks_t~~ key_callbacks;
112		wi_~~hash_value_callbacks_t~~ value_callbacks;
113
114		_wi_~~hash_bucket_t~~ **buckets;
	111	wi_dictionary_key_callbacks_t key_callbacks;
	112	wi_dictionary_value_callbacks_t value_callbacks;
	113
	114	_wi_dictionary_bucket_t **buckets;
115	115	wi_uinteger_t buckets_count;
116	116	wi_uinteger_t min_count;
…	…
119	119	wi_rwlock_t *lock;
120	120
121		_wi_~~hash_bucket_t~~ **bucket_chunks;
	121	_wi_dictionary_bucket_t **bucket_chunks;
122	122	wi_uinteger_t bucket_chunks_count;
123	123	wi_uinteger_t bucket_chunks_offset;
124	124
125		_wi_~~hash_bucket_t~~ *bucket_free_list;
	125	_wi_dictionary_bucket_t *bucket_free_list;
126	126	};
127	127
128	128
129		static void _wi_~~hash~~_dealloc(wi_runtime_instance_t *);
130		static wi_runtime_instance_t * _wi_~~hash~~_copy(wi_runtime_instance_t *);
131		static wi_boolean_t _wi_~~hash~~_is_equal(wi_runtime_instance_t , wi_runtime_instance_t );
132		static wi_string_t * _wi_~~hash~~_description(wi_runtime_instance_t *);
133		static wi_hash_code_t _wi_~~hash~~_hash(wi_runtime_instance_t *);
134
135		static _wi_~~hash_bucket_t * _wi_enumerator_hash~~_enumerator(wi_runtime_instance_t , wi_enumerator_context_t );
136
137		static void _wi_~~hash_resize(wi_hash~~_t *);
138
139		static _wi_~~hash_bucket_t * _wi_hash_bucket_create(wi_hash~~_t *);
140		static _wi_~~hash_bucket_t * _wi_hash_bucket_for_key(wi_hash~~_t , void , wi_uinteger_t);
141		static void _wi_~~hash_bucket_remove(wi_hash_t , _wi_hash~~_bucket_t );
	129	static void _wi_dictionary_dealloc(wi_runtime_instance_t *);
	130	static wi_runtime_instance_t * _wi_dictionary_copy(wi_runtime_instance_t *);
	131	static wi_boolean_t _wi_dictionary_is_equal(wi_runtime_instance_t , wi_runtime_instance_t );
	132	static wi_string_t * _wi_dictionary_description(wi_runtime_instance_t *);
	133	static wi_hash_code_t _wi_dictionary_hash(wi_runtime_instance_t *);
	134
	135	static _wi_dictionary_bucket_t * _wi_enumerator_dictionary_enumerator(wi_runtime_instance_t , wi_enumerator_context_t );
	136
	137	static void _wi_dictionary_resize(wi_dictionary_t *);
	138
	139	static _wi_dictionary_bucket_t * _wi_dictionary_bucket_create(wi_dictionary_t *);
	140	static _wi_dictionary_bucket_t * _wi_dictionary_bucket_for_key(wi_dictionary_t , void , wi_uinteger_t);
	141	static void _wi_dictionary_bucket_remove(wi_dictionary_t , _wi_dictionary_bucket_t );
142	142	#ifdef HAVE_QSORT_R
143		static int _wi_~~hash~~_compare_buckets(void , const void , const void *);
	143	static int _wi_dictionary_compare_buckets(void , const void , const void *);
144	144	#else
145		static int _wi_~~hash~~_compare_buckets(const void , const void );
	145	static int _wi_dictionary_compare_buckets(const void , const void );
146	146	#endif
147	147
148	148
149		const wi_~~hash_key_callbacks_t wi_hash~~_default_key_callbacks = {
	149	const wi_dictionary_key_callbacks_t wi_dictionary_default_key_callbacks = {
150	150	wi_copy,
151	151	wi_release,
…	…
155	155	};
156	156
157		const wi_~~hash_key_callbacks_t wi_hash~~_null_key_callbacks = {
	157	const wi_dictionary_key_callbacks_t wi_dictionary_null_key_callbacks = {
158	158	NULL,
159	159	NULL,
…	…
163	163	};
164	164
165		const wi_~~hash_value_callbacks_t wi_hash~~_default_value_callbacks = {
	165	const wi_dictionary_value_callbacks_t wi_dictionary_default_value_callbacks = {
166	166	wi_retain,
167	167	wi_release,
…	…
170	170	};
171	171
172		const wi_~~hash_value_callbacks_t wi_hash~~_null_value_callbacks = {
	172	const wi_dictionary_value_callbacks_t wi_dictionary_null_value_callbacks = {
173	173	NULL,
174	174	NULL,
…	…
177	177	};
178	178
179		static wi_uinteger_t _wi_~~hash~~_buckets_per_page;
	179	static wi_uinteger_t _wi_dictionary_buckets_per_page;
180	180
181	181	#ifndef HAVE_QSORT_R
182		static wi_lock_t *_wi_~~hash~~_sort_lock;
183		static wi_compare_func_t *_wi_~~hash~~_sort_function;
	182	static wi_lock_t *_wi_dictionary_sort_lock;
	183	static wi_compare_func_t *_wi_dictionary_sort_function;
184	184	#endif
185	185
186		static wi_runtime_id_t _wi_~~hash~~_runtime_id = WI_RUNTIME_ID_NULL;
187		static wi_runtime_class_t _wi_~~hash~~_runtime_class = {
188		"wi_~~hash~~_t",
189		_wi_~~hash~~_dealloc,
190		_wi_~~hash~~_copy,
191		_wi_~~hash~~_is_equal,
192		_wi_~~hash~~_description,
193		_wi_~~hash~~_hash
	186	static wi_runtime_id_t _wi_dictionary_runtime_id = WI_RUNTIME_ID_NULL;
	187	static wi_runtime_class_t _wi_dictionary_runtime_class = {
	188	"wi_dictionary_t",
	189	_wi_dictionary_dealloc,
	190	_wi_dictionary_copy,
	191	_wi_dictionary_is_equal,
	192	_wi_dictionary_description,
	193	_wi_dictionary_hash
194	194	};
195	195
196	196
197	197
198		void wi_~~hash~~_register(void) {
199		_wi_~~hash_runtime_id = wi_runtime_register_class(&_wi_hash~~_runtime_class);
200		}
201
202
203
204		void wi_~~hash~~_initialize(void) {
205		_wi_~~hash_buckets_per_page = wi_page_size() / sizeof(_wi_hash~~_bucket_t);
	198	void wi_dictionary_register(void) {
	199	_wi_dictionary_runtime_id = wi_runtime_register_class(&_wi_dictionary_runtime_class);
	200	}
	201
	202
	203
	204	void wi_dictionary_initialize(void) {
	205	_wi_dictionary_buckets_per_page = wi_page_size() / sizeof(_wi_dictionary_bucket_t);
206	206
207	207	#ifndef HAVE_QSORT_R
208		_wi_~~hash~~_sort_lock = wi_lock_init(wi_lock_alloc());
	208	_wi_dictionary_sort_lock = wi_lock_init(wi_lock_alloc());
209	209	#endif
210	210	}
…	…
214	214	#pragma mark -
215	215
216		wi_runtime_id_t wi_~~hash~~_runtime_id(void) {
217		return _wi_~~hash~~_runtime_id;
218		}
219
220
221
222		#pragma mark -
223
224		wi_~~hash_t * wi_hash~~_with_data_and_keys(void data0, void key0, ...) {
225		wi_~~hash_t *hash~~;
226		void data, key;
227		va_list ap;
228
229		~~hash = wi_hash_init_with_capacity(wi_hash~~_alloc(), 0);
230
231		wi_~~hash_set_data_for_key(hash~~, data0, key0);
	216	wi_runtime_id_t wi_dictionary_runtime_id(void) {
	217	return _wi_dictionary_runtime_id;
	218	}
	219
	220
	221
	222	#pragma mark -
	223
	224	wi_dictionary_t * wi_dictionary_with_data_and_keys(void data0, void key0, ...) {
	225	wi_dictionary_t *dictionary;
	226	void data, key;
	227	va_list ap;
	228
	229	dictionary = wi_dictionary_init_with_capacity(wi_dictionary_alloc(), 0);
	230
	231	wi_dictionary_set_data_for_key(dictionary, data0, key0);
232	232
233	233	va_start(ap, key0);
…	…
235	235	key = va_arg(ap, void *);
236	236
237		wi_~~hash_set_data_for_key(hash~~, data, key);
	237	wi_dictionary_set_data_for_key(dictionary, data, key);
238	238	}
239	239	va_end(ap);
240	240
241		return wi_autorelease(~~hash~~);
	241	return wi_autorelease(dictionary);
242	242	}
243	243
…	…
246	246	#ifdef WI_LIBXML2
247	247
248		wi_~~hash_t * wi_hash~~_with_plist_file(wi_string_t *path) {
249		return wi_autorelease(wi_~~hash_init_with_plist_file(wi_hash~~_alloc(), path));
	248	wi_dictionary_t * wi_dictionary_with_plist_file(wi_string_t *path) {
	249	return wi_autorelease(wi_dictionary_init_with_plist_file(wi_dictionary_alloc(), path));
250	250	}
251	251
…	…
256	256	#pragma mark -
257	257
258		wi_hash_t * wi_hash_alloc(void) {
259		return wi_runtime_create_instance(_wi_hash_runtime_id, sizeof(wi_hash_t));
260		}
261
262
263
264		wi_hash_t * wi_hash_init(wi_hash_t *hash) {
265		return wi_hash_init_with_capacity(hash, 0);
266		}
267
268
269
270		wi_hash_t * wi_hash_init_with_capacity(wi_hash_t *hash, wi_uinteger_t capacity) {
271		return wi_hash_init_with_capacity_and_callbacks(hash, capacity, wi_hash_default_key_callbacks, wi_hash_default_value_callbacks);
272		}
273
274
275
276		wi_hash_t * wi_hash_init_with_capacity_and_callbacks(wi_hash_t *hash, wi_uinteger_t capacity, wi_hash_key_callbacks_t key_callbacks, wi_hash_value_callbacks_t value_callbacks) {
277		hash->key_callbacks = key_callbacks;
278		hash->value_callbacks = value_callbacks;
279		hash->bucket_chunks_offset = _wi_hash_buckets_per_page;
280		hash->min_count = WI_MAX(wi_exp2m1(wi_log2(capacity) + 1), _WI_HASH_MIN_COUNT);
281		hash->buckets_count = hash->min_count;
282		hash->buckets = wi_malloc(hash->buckets_count * sizeof(_wi_hash_bucket_t *));
283		hash->lock = wi_rwlock_init(wi_rwlock_alloc());
284
285		return hash;
286		}
287
288
289
290		wi_hash_t * wi_hash_init_with_data_and_keys(wi_hash_t *hash, ...) {
	258	wi_dictionary_t * wi_dictionary_alloc(void) {
	259	return wi_runtime_create_instance(_wi_dictionary_runtime_id, sizeof(wi_dictionary_t));
	260	}
	261
	262
	263
	264	wi_dictionary_t * wi_dictionary_init(wi_dictionary_t *dictionary) {
	265	return wi_dictionary_init_with_capacity(dictionary, 0);
	266	}
	267
	268
	269
	270	wi_dictionary_t * wi_dictionary_init_with_capacity(wi_dictionary_t *dictionary, wi_uinteger_t capacity) {
	271	return wi_dictionary_init_with_capacity_and_callbacks(dictionary, capacity,
	272	wi_dictionary_default_key_callbacks, wi_dictionary_default_value_callbacks);
	273	}
	274
	275
	276
	277	wi_dictionary_t * wi_dictionary_init_with_capacity_and_callbacks(wi_dictionary_t *dictionary, wi_uinteger_t capacity, wi_dictionary_key_callbacks_t key_callbacks, wi_dictionary_value_callbacks_t value_callbacks) {
	278	dictionary->key_callbacks = key_callbacks;
	279	dictionary->value_callbacks = value_callbacks;
	280	dictionary->bucket_chunks_offset = _wi_dictionary_buckets_per_page;
	281	dictionary->min_count = WI_MAX(wi_exp2m1(wi_log2(capacity) + 1), _WI_DICTIONARY_MIN_COUNT);
	282	dictionary->buckets_count = dictionary->min_count;
	283	dictionary->buckets = wi_malloc(dictionary->buckets_count * sizeof(_wi_dictionary_bucket_t *));
	284	dictionary->lock = wi_rwlock_init(wi_rwlock_alloc());
	285
	286	return dictionary;
	287	}
	288
	289
	290
	291	wi_dictionary_t * wi_dictionary_init_with_data_and_keys(wi_dictionary_t *dictionary, ...) {
291	292	void data, key;
292	293	va_list ap;
293	294
294		~~hash = wi_hash_init_with_capacity(hash~~, 0);
295
296		va_start(ap, ~~hash~~);
	295	dictionary = wi_dictionary_init_with_capacity(dictionary, 0);
	296
	297	va_start(ap, dictionary);
297	298	while((data = va_arg(ap, void *))) {
298	299	key = va_arg(ap, void *);
299	300
300		wi_~~hash_set_data_for_key(hash~~, data, key);
	301	wi_dictionary_set_data_for_key(dictionary, data, key);
301	302	}
302	303	va_end(ap);
303	304
304		return ~~hash~~;
	305	return dictionary;
305	306	}
306	307
…	…
309	310	#ifdef WI_LIBXML2
310	311
311		wi_~~hash_t * wi_hash_init_with_plist_file(wi_hash_t hash~~, wi_string_t path) {
	312	wi_dictionary_t * wi_dictionary_init_with_plist_file(wi_dictionary_t dictionary, wi_string_t path) {
312	313	wi_runtime_instance_t *instance;
313	314
314		wi_release(~~hash~~);
	315	wi_release(dictionary);
315	316
316	317	instance = wi_plist_read_instance_from_file(path);
…	…
319	320	return NULL;
320	321
321		if(wi_runtime_id(instance) != wi_~~hash~~_runtime_id())
	322	if(wi_runtime_id(instance) != wi_dictionary_runtime_id())
322	323	return NULL;
323	324
…	…
329	330
330	331
331		static wi_runtime_instance_t * _wi_hash_copy(wi_runtime_instance_t *instance) {
332		wi_hash_t hash = instance, hash_copy;
333		_wi_hash_bucket_t *bucket;
	332	static wi_runtime_instance_t * _wi_dictionary_copy(wi_runtime_instance_t *instance) {
	333	wi_dictionary_t dictionary = instance, dictionary_copy;
	334	_wi_dictionary_bucket_t *bucket;
	335	wi_uinteger_t i;
	336
	337	dictionary_copy = wi_dictionary_init_with_capacity_and_callbacks(wi_dictionary_alloc(), dictionary->key_count,
	338	dictionary->key_callbacks, dictionary->value_callbacks);
	339
	340	for(i = 0; i < dictionary->buckets_count; i++) {
	341	for(bucket = dictionary->buckets[i]; bucket; bucket = bucket->next)
	342	wi_dictionary_set_data_for_key(dictionary_copy, bucket->data, bucket->key);
	343	}
	344
	345	return dictionary_copy;
	346	}
	347
	348
	349
	350	static void _wi_dictionary_dealloc(wi_runtime_instance_t *instance) {
	351	wi_dictionary_t *dictionary = instance;
334	352	wi_uinteger_t i;
335
336		hash_copy = wi_hash_init_with_capacity_and_callbacks(wi_hash_alloc(), hash->key_count, hash->key_callbacks, hash->value_callbacks);
337
338		for(i = 0; i < hash->buckets_count; i++) {
339		for(bucket = hash->buckets[i]; bucket; bucket = bucket->next)
340		wi_hash_set_data_for_key(hash_copy, bucket->data, bucket->key);
341		}
342
343		return hash_copy;
344		}
345
346
347
348		static void _wi_hash_dealloc(wi_runtime_instance_t *instance) {
349		wi_hash_t *hash = instance;
350		wi_uinteger_t i;
351
352		wi_hash_remove_all_data(hash);
353
354		if(hash->bucket_chunks) {
355		for(i = 0; i < hash->bucket_chunks_count; i++)
356		wi_free(hash->bucket_chunks[i]);
357
358		wi_free(hash->bucket_chunks);
359		}
360
361		wi_free(hash->buckets);
362
363		wi_release(hash->lock);
364		}
365
366
367
368		static wi_boolean_t _wi_hash_is_equal(wi_runtime_instance_t instance1, wi_runtime_instance_t instance2) {
369		wi_hash_t *hash1 = instance1;
370		wi_hash_t *hash2 = instance2;
371		_wi_hash_bucket_t *bucket;
372		wi_uinteger_t i;
373
374		if(hash1->key_count != hash2->key_count)
	353
	354	wi_dictionary_remove_all_data(dictionary);
	355
	356	if(dictionary->bucket_chunks) {
	357	for(i = 0; i < dictionary->bucket_chunks_count; i++)
	358	wi_free(dictionary->bucket_chunks[i]);
	359
	360	wi_free(dictionary->bucket_chunks);
	361	}
	362
	363	wi_free(dictionary->buckets);
	364
	365	wi_release(dictionary->lock);
	366	}
	367
	368
	369
	370	static wi_boolean_t _wi_dictionary_is_equal(wi_runtime_instance_t instance1, wi_runtime_instance_t instance2) {
	371	wi_dictionary_t *dictionary1 = instance1;
	372	wi_dictionary_t *dictionary2 = instance2;
	373	_wi_dictionary_bucket_t *bucket;
	374	wi_uinteger_t i;
	375
	376	if(dictionary1->key_count != dictionary2->key_count)
375	377	return false;
376	378
377		if(~~hash1->value_callbacks.is_equal != hash~~2->value_callbacks.is_equal)
	379	if(dictionary1->value_callbacks.is_equal != dictionary2->value_callbacks.is_equal)
378	380	return false;
379	381
380		for(i = 0; i < hash1->buckets_count; i++) {
381		for(bucket = hash1->buckets[i]; bucket; bucket = bucket->next) {
382		if(!_WI_HASH_VALUE_IS_EQUAL(hash1, bucket->data, wi_hash_data_for_key(hash2, bucket->key))) {
383		wi_log_info(WI_STR("%@ %@ != %@"), bucket->key, bucket->data, wi_hash_data_for_key(hash2, bucket->key));
	382	for(i = 0; i < dictionary1->buckets_count; i++) {
	383	for(bucket = dictionary1->buckets[i]; bucket; bucket = bucket->next) {
	384	if(!_WI_DICTIONARY_VALUE_IS_EQUAL(dictionary1, bucket->data, wi_dictionary_data_for_key(dictionary2, bucket->key)))
384	385	return false;
385		}
386	386	}
387	387	}
…	…
392	392
393	393
394		static wi_string_t * _wi_~~hash~~_description(wi_runtime_instance_t *instance) {
395		wi_~~hash_t *hash~~ = instance;
396		_wi_~~hash_bucket_t~~ *bucket;
397		wi_string_t string, key_description, *value_description;
398		wi_uinteger_t i;
	394	static wi_string_t * _wi_dictionary_description(wi_runtime_instance_t *instance) {
	395	wi_dictionary_t *dictionary = instance;
	396	_wi_dictionary_bucket_t *bucket;
	397	wi_string_t string, key_description, *value_description;
	398	wi_uinteger_t i;
399	399
400	400	string = wi_string_with_format(WI_STR("<%@ %p>{count = %lu, values = (\n"),
401		wi_runtime_class_name(~~hash~~),
402		~~hash~~,
403		~~hash~~->key_count);
404
405		for(i = 0; i < ~~hash~~->buckets_count; i++) {
406		for(bucket = ~~hash~~->buckets[i]; bucket; bucket = bucket->next) {
407		if(~~hash~~->key_callbacks.description)
408		key_description = (*~~hash~~->key_callbacks.description)(bucket->key);
	401	wi_runtime_class_name(dictionary),
	402	dictionary,
	403	dictionary->key_count);
	404
	405	for(i = 0; i < dictionary->buckets_count; i++) {
	406	for(bucket = dictionary->buckets[i]; bucket; bucket = bucket->next) {
	407	if(dictionary->key_callbacks.description)
	408	key_description = (*dictionary->key_callbacks.description)(bucket->key);
409	409	else
410	410	key_description = wi_string_with_format(WI_STR("%p"), bucket->key);
411	411
412		if(~~hash~~->value_callbacks.description)
413		value_description = (*~~hash~~->value_callbacks.description)(bucket->data);
	412	if(dictionary->value_callbacks.description)
	413	value_description = (*dictionary->value_callbacks.description)(bucket->data);
414	414	else
415	415	value_description = wi_string_with_format(WI_STR("%p"), bucket->data);
…	…
426	426
427	427
428		static wi_hash_code_t _wi_~~hash~~_hash(wi_runtime_instance_t *instance) {
429		wi_~~hash_t *hash~~ = instance;
430
431		return ~~hash~~->key_count;
432		}
433
434
435		#pragma mark -
436
437		void wi_~~hash_wrlock(wi_hash_t *hash~~) {
438		wi_rwlock_wrlock(~~hash~~->lock);
439		}
440
441
442
443		void wi_~~hash_rdlock(wi_hash_t *hash~~) {
444		wi_rwlock_rdlock(~~hash~~->lock);
445		}
446
447
448
449		void wi_~~hash_unlock(wi_hash_t *hash~~) {
450		wi_rwlock_unlock(~~hash~~->lock);
451		}
452
453
454
455		#pragma mark -
456
457		wi_uinteger_t wi_~~hash_count(wi_hash_t *hash~~) {
458		return ~~hash~~->key_count;
459		}
460
461
462
463		wi_array_t * wi_~~hash_all_keys(wi_hash_t *hash~~) {
464		wi_array_t *array;
465		_wi_~~hash~~_bucket_t *bucket;
466		wi_array_callbacks_t callbacks;
467		wi_uinteger_t i;
468
469		callbacks.retain = ~~hash~~->key_callbacks.retain;
470		callbacks.release = ~~hash~~->key_callbacks.release;
471		callbacks.is_equal = ~~hash~~->key_callbacks.is_equal;
472		callbacks.description = ~~hash~~->key_callbacks.description;
473		array = wi_array_init_with_capacity_and_callbacks(wi_array_alloc(), ~~hash~~->key_count, callbacks);
474
475		for(i = 0; i < ~~hash~~->buckets_count; i++) {
476		for(bucket = ~~hash~~->buckets[i]; bucket; bucket = bucket->next)
	428	static wi_hash_code_t _wi_dictionary_hash(wi_runtime_instance_t *instance) {
	429	wi_dictionary_t *dictionary = instance;
	430
	431	return dictionary->key_count;
	432	}
	433
	434
	435	#pragma mark -
	436
	437	void wi_dictionary_wrlock(wi_dictionary_t *dictionary) {
	438	wi_rwlock_wrlock(dictionary->lock);
	439	}
	440
	441
	442
	443	void wi_dictionary_rdlock(wi_dictionary_t *dictionary) {
	444	wi_rwlock_rdlock(dictionary->lock);
	445	}
	446
	447
	448
	449	void wi_dictionary_unlock(wi_dictionary_t *dictionary) {
	450	wi_rwlock_unlock(dictionary->lock);
	451	}
	452
	453
	454
	455	#pragma mark -
	456
	457	wi_uinteger_t wi_dictionary_count(wi_dictionary_t *dictionary) {
	458	return dictionary->key_count;
	459	}
	460
	461
	462
	463	wi_array_t * wi_dictionary_all_keys(wi_dictionary_t *dictionary) {
	464	wi_array_t *array;
	465	_wi_dictionary_bucket_t *bucket;
	466	wi_array_callbacks_t callbacks;
	467	wi_uinteger_t i;
	468
	469	callbacks.retain = dictionary->key_callbacks.retain;
	470	callbacks.release = dictionary->key_callbacks.release;
	471	callbacks.is_equal = dictionary->key_callbacks.is_equal;
	472	callbacks.description = dictionary->key_callbacks.description;
	473	array = wi_array_init_with_capacity_and_callbacks(wi_array_alloc(), dictionary->key_count, callbacks);
	474
	475	for(i = 0; i < dictionary->buckets_count; i++) {
	476	for(bucket = dictionary->buckets[i]; bucket; bucket = bucket->next)
477	477	wi_array_add_data(array, bucket->key);
478	478	}
…	…
483	483
484	484
485		wi_array_t * wi_~~hash_all_values(wi_hash_t *hash~~) {
486		wi_array_t *array;
487		_wi_~~hash~~_bucket_t *bucket;
488		wi_array_callbacks_t callbacks;
489		wi_uinteger_t i;
490
491		callbacks.retain = ~~hash~~->value_callbacks.retain;
492		callbacks.release = ~~hash~~->value_callbacks.release;
493		callbacks.is_equal = ~~hash~~->value_callbacks.is_equal;
494		callbacks.description = ~~hash~~->value_callbacks.description;
495		array = wi_array_init_with_capacity_and_callbacks(wi_array_alloc(), ~~hash~~->key_count, callbacks);
496
497		for(i = 0; i < ~~hash~~->buckets_count; i++) {
498		for(bucket = ~~hash~~->buckets[i]; bucket; bucket = bucket->next)
	485	wi_array_t * wi_dictionary_all_values(wi_dictionary_t *dictionary) {
	486	wi_array_t *array;
	487	_wi_dictionary_bucket_t *bucket;
	488	wi_array_callbacks_t callbacks;
	489	wi_uinteger_t i;
	490
	491	callbacks.retain = dictionary->value_callbacks.retain;
	492	callbacks.release = dictionary->value_callbacks.release;
	493	callbacks.is_equal = dictionary->value_callbacks.is_equal;
	494	callbacks.description = dictionary->value_callbacks.description;
	495	array = wi_array_init_with_capacity_and_callbacks(wi_array_alloc(), dictionary->key_count, callbacks);
	496
	497	for(i = 0; i < dictionary->buckets_count; i++) {
	498	for(bucket = dictionary->buckets[i]; bucket; bucket = bucket->next)
499	499	wi_array_add_data(array, bucket->data);
500	500	}
…	…
505	505
506	506
507		wi_array_t * wi_~~hash_keys_sorted_by_value(wi_hash_t hash~~, wi_compare_func_t compare) {
508		wi_array_t array, buckets;
509		_wi_~~hash~~_bucket_t *bucket;
510		wi_array_callbacks_t callbacks;
511		void **data;
512		wi_uinteger_t i;
513
514		if(~~hash~~->key_count == 0)
	507	wi_array_t * wi_dictionary_keys_sorted_by_value(wi_dictionary_t dictionary, wi_compare_func_t compare) {
	508	wi_array_t array, buckets;
	509	_wi_dictionary_bucket_t *bucket;
	510	wi_array_callbacks_t callbacks;
	511	&nbs