void
g_hash_table_destroy (GHashTable *hash_table)
{
guint i;
for (i = 0; i < HASH_TABLE_SIZE; i++)
g_hash_nodes_destroy (hash_table->nodes[i],
hash_table->key_destroy_func,
hash_table->value_destroy_func);
libspectrum_free (hash_table->nodes);
libspectrum_free (hash_table);
}
/**
* g_hash_table_destroy:
* @hash_table: a #GHashTable.
*
* Destroys the #GHashTable. If keys and/or values are dynamically
* allocated, you should either free them first or create the #GHashTable
* using g_hash_table_new_full(). In the latter case the destroy functions
* you supplied will be called on all keys and values before destroying
* the #GHashTable.
**/
void
g_hash_table_destroy (GHashTable *hash_table)
{
guint i;
g_return_if_fail (hash_table != NULL);
for (i = 0; i < hash_table->size; i++)
g_hash_nodes_destroy (hash_table->nodes[i],
hash_table->key_destroy_func,
hash_table->value_destroy_func);
g_free (hash_table->nodes);
g_free (hash_table);
}
/**
* g_hash_table_steal_all:
* @hash_table: a #GHashTable.
*
* Removes all keys and their associated values from a #GHashTable
* without calling the key and value destroy functions.
*
* Since: 2.12
**/
void
g_hash_table_steal_all (GHashTable *hash_table)
{
guint i;
g_return_if_fail (hash_table != NULL);
for (i = 0; i < hash_table->size; i++)
{
g_hash_nodes_destroy (hash_table->nodes[i], NULL, NULL);
hash_table->nodes[i] = NULL;
}
hash_table->nnodes = 0;
G_HASH_TABLE_RESIZE (hash_table);
}
/**
* g_hash_table_remove_all:
* @hash_table: a #GHashTable
*
* Removes all keys and their associated values from a #GHashTable.
*
* If the #GHashTable was created using g_hash_table_new_full(), the keys
* and values are freed using the supplied destroy functions, otherwise you
* have to make sure that any dynamically allocated values are freed
* yourself.
*
* Since: 2.12
**/
void
g_hash_table_remove_all (GHashTable *hash_table)
{
guint i;
g_return_if_fail (hash_table != NULL);
for (i = 0; i < hash_table->size; i++)
{
g_hash_nodes_destroy (hash_table->nodes[i],
hash_table->key_destroy_func,
hash_table->value_destroy_func);
hash_table->nodes[i] = NULL;
}
hash_table->nnodes = 0;
G_HASH_TABLE_RESIZE (hash_table);
}
/**
* g_hash_table_unref:
* @hash_table: a valid #GHashTable.
*
* Atomically decrements the reference count of @hash_table by one.
* If the reference count drops to 0, all keys and values will be
* destroyed, and all memory allocated by the hash table is released.
* This function is MT-safe and may be called from any thread.
*
* Since: 2.10
**/
void
g_hash_table_unref (GHashTable *hash_table)
{
g_return_if_fail (hash_table != NULL);
g_return_if_fail (hash_table->ref_count > 0);
if (g_atomic_int_exchange_and_add (&hash_table->ref_count, -1) - 1 == 0)
{
gint i;
for (i = 0; i < hash_table->size; i++)
g_hash_nodes_destroy (hash_table->nodes[i],
hash_table->key_destroy_func,
hash_table->value_destroy_func);
g_free (hash_table->nodes);
g_slice_free (GHashTable, hash_table);
}
}
/**
* g_hash_table_destroy:
* @hash_table: a #GHashTable.
*
* Destroys the #GHashTable. If keys and/or values are dynamically
* allocated, you should either free them first or create the #GHashTable
* using g_hash_table_new_full(). In the latter case the destroy functions
* you supplied will be called on all keys and values before destroying
* the #GHashTable.
**/
void
mono_g_hash_table_destroy (MonoGHashTable *hash_table)
{
guint i;
g_return_if_fail (hash_table != NULL);
for (i = 0; i < hash_table->size; i++)
g_hash_nodes_destroy (hash_table->nodes[i], hash_table->gc_type,
hash_table->key_destroy_func,
hash_table->value_destroy_func);
#if HAVE_BOEHM_GC
#else
#if HAVE_SGEN_GC
mono_gc_deregister_root ((char*)hash_table);
#endif
g_free (hash_table->nodes);
g_free (hash_table);
#endif
}
