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_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

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

Definition at line 101 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);
}

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

Definition at line 106 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);
        }

        switch_core_hash_delete(hash, key);

        if (mutex) {
                switch_mutex_unlock(mutex);
        }

        return ret;
}

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

Definition at line 140 of file switch_core_hash.c.

References 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;
}

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

Definition at line 123 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_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;
}

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

Definition at line 176 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);
}

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

Definition at line 181 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;
}

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

Definition at line 199 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_hash_index_t* switch_core_hash_first_iter	(	switch_hash_t *	hash,
		switch_hash_index_t *	hi
	)

Definition at line 229 of file switch_core_hash.c.

References switch_hashtable_first_iter().

{
        return switch_hashtable_first_iter(hash, hi);
}

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_status_t switch_core_hash_insert_destructor	(	switch_hash_t *	hash,
		const char *	key,
		const void *	data,
		hashtable_destructor_t	destructor
	)

Definition at line 58 of file switch_core_hash.c.

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

{
        int r = 0;

        r = switch_hashtable_insert_destructor(hash, strdup(key), (void *)data, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_DUP_CHECK, destructor);
        
        return r ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

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 67 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_hash_index_t* switch_core_hash_next

(

switch_hash_index_t **

hi

)

Definition at line 234 of file switch_core_hash.c.

References switch_hashtable_next().

Referenced by switch_core_hash_delete_multi().

{
        return switch_hashtable_next(hi);
}

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

Definition at line 239 of file switch_core_hash.c.

References switch_hashtable_this().

Referenced by switch_core_hash_delete_multi().

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