switch_core_hash.c File Reference

#include <switch.h>
#include "private/switch_core_pvt.h"
#include "private/switch_hashtable_private.h"

Include dependency graph for switch_core_hash.c:

Go to the source code of this file.

Functions
switch_status_t	switch_core_hash_init_case (switch_hash_t **hash, switch_bool_t case_sensitive)
switch_status_t	switch_core_hash_destroy (switch_hash_t **hash)
switch_status_t	switch_core_hash_insert_pointer (switch_hash_t *hash, const void *data)
	Insert data into a hash with an auto-generated key based on the data pointer. More...
switch_status_t	switch_core_hash_insert_auto_free (switch_hash_t *hash, const char *key, const void *data)
	Insert data into a hash and set flags so the value is automatically freed on delete. More...
switch_status_t	switch_core_hash_insert_dup_auto_free (switch_hash_t *hash, const char *key, const char *str)
	Insert strdup(str) into a hash and set flags so the value is automatically freed on delete. More...
void *	switch_core_hash_insert_alloc_destructor (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ size_t size, hashtable_destructor_t destructor)
	Allocate memory and insert into a hash. More...
switch_status_t	switch_core_hash_insert_dup_destructor (switch_hash_t *hash, const char *key, const char *str, hashtable_destructor_t destructor)
switch_status_t	switch_core_hash_insert_destructor (switch_hash_t *hash, const char *key, const void *data, hashtable_destructor_t destructor)
switch_status_t	switch_core_hash_insert_locked (switch_hash_t *hash, const char *key, const void *data, switch_mutex_t *mutex)
switch_status_t	switch_core_hash_insert_wrlock (switch_hash_t *hash, const char *key, const void *data, switch_thread_rwlock_t *rwlock)
	Retrieve data from a given hash. More...
void *	switch_core_hash_delete (switch_hash_t *hash, const char *key)
void *	switch_core_hash_delete_locked (switch_hash_t *hash, const char *key, switch_mutex_t *mutex)
void *	switch_core_hash_delete_wrlock (switch_hash_t *hash, const char *key, switch_thread_rwlock_t *rwlock)
switch_status_t	switch_core_hash_delete_multi (switch_hash_t *hash, switch_hash_delete_callback_t callback, void *pData)
void *	switch_core_hash_find (switch_hash_t *hash, const char *key)
void *	switch_core_hash_find_locked (switch_hash_t *hash, const char *key, switch_mutex_t *mutex)
void *	switch_core_hash_find_rdlock (switch_hash_t *hash, const char *key, switch_thread_rwlock_t *rwlock)
switch_bool_t	switch_core_hash_empty (switch_hash_t *hash)
	tells if a hash is empty More...
switch_hash_index_t *	switch_core_hash_first_iter (switch_hash_t *hash, switch_hash_index_t *hi)
switch_hash_index_t *	switch_core_hash_next (switch_hash_index_t **hi)
void	switch_core_hash_this (switch_hash_index_t *hi, const void **key, switch_ssize_t *klen, void **val)
void	switch_core_hash_this_val (switch_hash_index_t *hi, void *val)
switch_status_t	switch_core_inthash_init (switch_inthash_t **hash)
switch_status_t	switch_core_inthash_destroy (switch_inthash_t **hash)
switch_status_t	switch_core_inthash_insert (switch_inthash_t *hash, uint32_t key, const void *data)
void *	switch_core_inthash_delete (switch_inthash_t *hash, uint32_t key)
void *	switch_core_inthash_find (switch_inthash_t *hash, uint32_t key)

Function Documentation

switch_core_hash_delete()

void* switch_core_hash_delete	(	switch_hash_t *	hash,
		const char *	key
	)

Definition at line 191 of file switch_core_hash.c.

References switch_hashtable_remove().

Referenced by switch_core_hash_delete_locked(), switch_core_hash_delete_multi(), and switch_core_hash_delete_wrlock().

{
        return switch_hashtable_remove(hash, (void *)key);
}

switch_core_hash_delete_locked()

void* switch_core_hash_delete_locked	(	switch_hash_t *	hash,
		const char *	key,
		switch_mutex_t *	mutex
	)

Definition at line 196 of file switch_core_hash.c.

References switch_core_hash_delete(), switch_mutex_lock(), and switch_mutex_unlock().

{
        void *ret = NULL;

        if (mutex) {
                switch_mutex_lock(mutex);
        }

        ret = switch_core_hash_delete(hash, key);

        if (mutex) {
                switch_mutex_unlock(mutex);
        }

        return ret;
}

switch_core_hash_delete_multi()

switch_status_t switch_core_hash_delete_multi	(	switch_hash_t *	hash,
		switch_hash_delete_callback_t	callback,
		void *	pData
	)

Definition at line 230 of file switch_core_hash.c.

References key, switch_event_header::next, switch_assert, switch_core_hash_delete(), switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create_subclass, switch_event_destroy(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and switch_event_header::value.

                                                                                                                                        {

        switch_hash_index_t *hi = NULL;
        switch_event_t *event = NULL;
        switch_event_header_t *header = NULL;
        switch_status_t status = SWITCH_STATUS_GENERR;

        switch_event_create_subclass(&event, SWITCH_EVENT_CLONE, NULL);
        switch_assert(event);

        /* iterate through the hash, call callback, if callback returns NULL or true, put the key on the list (event)
           When done, iterate through the list deleting hash entries
         */

        for (hi = switch_core_hash_first(hash); hi; hi = switch_core_hash_next(&hi)) {
                const void *key;
                void *val;
                switch_core_hash_this(hi, &key, NULL, &val);
                if (!callback || callback(key, val, pData)) {
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "delete", (const char *) key);
                }
        }

        /* now delete them */
        for (header = event->headers; header; header = header->next) {
                if (switch_core_hash_delete(hash, header->value)) {
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

        switch_event_destroy(&event);

        return status;
}

switch_core_hash_delete_wrlock()

void* switch_core_hash_delete_wrlock	(	switch_hash_t *	hash,
		const char *	key,
		switch_thread_rwlock_t *	rwlock
	)

Definition at line 213 of file switch_core_hash.c.

References switch_core_hash_delete(), switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        void *ret = NULL;

        if (rwlock) {
                switch_thread_rwlock_wrlock(rwlock);
        }

        ret = switch_core_hash_delete(hash, key);

        if (rwlock) {
                switch_thread_rwlock_unlock(rwlock);
        }

        return ret;
}

switch_core_hash_destroy()

switch_status_t switch_core_hash_destroy

(

switch_hash_t **

hash

)

Definition at line 49 of file switch_core_hash.c.

References switch_assert, switch_hashtable_destroy(), and SWITCH_STATUS_SUCCESS.

{
        switch_assert(hash != NULL && *hash != NULL);

        switch_hashtable_destroy(hash);

        return SWITCH_STATUS_SUCCESS;
}

switch_core_hash_find()

void* switch_core_hash_find	(	switch_hash_t *	hash,
		const char *	key
	)

Definition at line 266 of file switch_core_hash.c.

References switch_hashtable_search().

Referenced by switch_core_hash_find_locked(), and switch_core_hash_find_rdlock().

{
        return switch_hashtable_search(hash, (void *)key);
}

switch_core_hash_find_locked()

void* switch_core_hash_find_locked	(	switch_hash_t *	hash,
		const char *	key,
		switch_mutex_t *	mutex
	)

Definition at line 271 of file switch_core_hash.c.

References switch_core_hash_find(), switch_mutex_lock(), and switch_mutex_unlock().

{
        void *val;

        if (mutex) {
                switch_mutex_lock(mutex);
        }

        val = switch_core_hash_find(hash, key);


        if (mutex) {
                switch_mutex_unlock(mutex);
        }

        return val;
}

switch_core_hash_find_rdlock()

void* switch_core_hash_find_rdlock	(	switch_hash_t *	hash,
		const char *	key,
		switch_thread_rwlock_t *	rwlock
	)

Definition at line 289 of file switch_core_hash.c.

References switch_core_hash_find(), switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

{
        void *val;

        if (rwlock) {
                switch_thread_rwlock_rdlock(rwlock);
        }

        val = switch_core_hash_find(hash, key);

        if (rwlock) {
                switch_thread_rwlock_unlock(rwlock);
        }

        return val;
}

switch_core_hash_first_iter()

switch_hash_index_t* switch_core_hash_first_iter	(	switch_hash_t *	hash,
		switch_hash_index_t *	hi
	)

Definition at line 319 of file switch_core_hash.c.

References switch_hashtable_first_iter().

{
        return switch_hashtable_first_iter(hash, hi);
}

switch_core_hash_init_case()

switch_status_t switch_core_hash_init_case	(	switch_hash_t **	hash,
		switch_bool_t	case_sensitive
	)

Definition at line 39 of file switch_core_hash.c.

References switch_create_hashtable(), switch_hash_default(), switch_hash_default_ci(), switch_hash_equalkeys(), and switch_hash_equalkeys_ci().

{
        if (case_sensitive) {
                return switch_create_hashtable(hash, 16, switch_hash_default, switch_hash_equalkeys);
        } else {
                return switch_create_hashtable(hash, 16, switch_hash_default_ci, switch_hash_equalkeys_ci);
        }
}

switch_core_hash_insert_destructor()

switch_status_t switch_core_hash_insert_destructor	(	switch_hash_t *	hash,
		const char *	key,
		const void *	data,
		hashtable_destructor_t	destructor
	)

Definition at line 144 of file switch_core_hash.c.

References HASHTABLE_DUP_CHECK, HASHTABLE_FLAG_FREE_KEY, switch_hashtable_insert_destructor(), switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        char *dkey = strdup(key);

        if (switch_hashtable_insert_destructor(hash, dkey, (void *)data, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_DUP_CHECK, destructor)) {
                return SWITCH_STATUS_SUCCESS;
        }

        switch_safe_free(dkey);

        return SWITCH_STATUS_FALSE;
}

switch_core_hash_insert_dup_destructor()

switch_status_t switch_core_hash_insert_dup_destructor	(	switch_hash_t *	hash,
		const char *	key,
		const char *	str,
		hashtable_destructor_t	destructor
	)

Definition at line 127 of file switch_core_hash.c.

References HASHTABLE_DUP_CHECK, HASHTABLE_FLAG_FREE_KEY, switch_hashtable_insert_destructor(), switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        char *dkey = strdup(key);
        char *dup = strdup(str);

        assert(dup);

        if (switch_hashtable_insert_destructor(hash, dkey, (void *)dup, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_DUP_CHECK, destructor)) {
                return SWITCH_STATUS_SUCCESS;
        }

        switch_safe_free(dup);
        switch_safe_free(dkey);

        return SWITCH_STATUS_FALSE;
}

switch_core_hash_insert_locked()

switch_status_t switch_core_hash_insert_locked	(	switch_hash_t *	hash,
		const char *	key,
		const void *	data,
		switch_mutex_t *	mutex
	)

Definition at line 157 of file switch_core_hash.c.

References switch_core_hash_insert, switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_FALSE.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (mutex) {
                switch_mutex_lock(mutex);
        }

        status = switch_core_hash_insert(hash, key, data);

        if (mutex) {
                switch_mutex_unlock(mutex);
        }

        return status;
}

switch_core_hash_next()

switch_hash_index_t* switch_core_hash_next

(

switch_hash_index_t **

hi

)

Definition at line 324 of file switch_core_hash.c.

References switch_hashtable_next().

Referenced by switch_core_hash_delete_multi().

{
        return switch_hashtable_next(hi);
}

switch_core_hash_this()

void switch_core_hash_this	(	switch_hash_index_t *	hi,
		const void **	key,
		switch_ssize_t *	klen,
		void **	val
	)

Definition at line 329 of file switch_core_hash.c.

References switch_hashtable_this().

Referenced by switch_core_hash_delete_multi().

{
        switch_hashtable_this(hi, key, klen, val);
}