switch_core_hash.c File Reference

#include <switch.h>
#include "private/switch_core_pvt.h"
#include <sqlite3.h>
#include "../../../libs/sqlite/src/hash.h"

Include dependency graph for switch_core_hash.c:

Go to the source code of this file.

Data Structures
struct	switch_hash
Functions
switch_status_t	switch_core_hash_init_case (switch_hash_t **hash, switch_memory_pool_t *pool, switch_bool_t case_sensitive)
switch_status_t	switch_core_hash_destroy (switch_hash_t **hash)
switch_status_t	switch_core_hash_insert (switch_hash_t *hash, const char *key, const void *data)
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.
switch_status_t	switch_core_hash_delete (switch_hash_t *hash, const char *key)
switch_status_t	switch_core_hash_delete_locked (switch_hash_t *hash, const char *key, switch_mutex_t *mutex)
switch_status_t	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_hash_index_t *	switch_hash_first (char *deprecate_me, switch_hash_t *hash)
switch_hash_index_t *	switch_hash_next (switch_hash_index_t *hi)
void	switch_hash_this (switch_hash_index_t *hi, const void **key, switch_ssize_t *klen, void **val)

---

Function Documentation

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

Definition at line 114 of file switch_core_hash.c.

References SWITCH_STATUS_SUCCESS.

{
        sqlite3HashInsert(&hash->table, key, (int) strlen(key) + 1, NULL);
        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 120 of file switch_core_hash.c.

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

{
        if (mutex) {
                switch_mutex_lock(mutex);
        }

        sqlite3HashInsert(&hash->table, key, (int) strlen(key) + 1, NULL);

        if (mutex) {
                switch_mutex_unlock(mutex);
        }

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 150 of file switch_core_hash.c.

References switch_event::headers, switch_event_header::next, switch_assert, switch_core_hash_delete(), switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create_subclass, switch_event_destroy(), switch_hash_first(), switch_hash_next(), switch_hash_this(), 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 true, put the key on the list (event)
           When done, iterate through the list deleting hash entries
         */
        
        for (hi = switch_hash_first(NULL, hash); hi; hi = switch_hash_next(hi)) {
                const void *key;
                void *val;
                switch_hash_this(hi, &key, NULL, &val);
                if (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) == SWITCH_STATUS_SUCCESS) {
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

        switch_event_destroy(&event);
        
        return status;
}

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

Definition at line 135 of file switch_core_hash.c.

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

{
        if (rwlock) {
                switch_thread_rwlock_wrlock(rwlock);
        }

        sqlite3HashInsert(&hash->table, key, (int) strlen(key) + 1, NULL);

        if (rwlock) {
                switch_thread_rwlock_unlock(rwlock);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_core_hash_destroy

(

switch_hash_t **

hash

)

Definition at line 64 of file switch_core_hash.c.

References switch_assert, and SWITCH_STATUS_SUCCESS.

{
        switch_assert(hash != NULL && *hash != NULL);
        sqlite3HashClear(&(*hash)->table);

        if (!(*hash)->pool) {
                free(*hash);
        }

        *hash = NULL;

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 186 of file switch_core_hash.c.

{
        return sqlite3HashFind(&hash->table, key, (int) strlen(key) + 1);
}

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

Definition at line 191 of file switch_core_hash.c.

References switch_mutex_lock(), and switch_mutex_unlock().

{
        void *val;

        if (mutex) {
                switch_mutex_lock(mutex);
        }

        val = sqlite3HashFind(&hash->table, key, (int) strlen(key) + 1);

        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 208 of file switch_core_hash.c.

References switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

{
        void *val;

        if (rwlock) {
                switch_thread_rwlock_rdlock(rwlock);
        }

        val = sqlite3HashFind(&hash->table, key, (int) strlen(key) + 1);

        if (rwlock) {
                switch_thread_rwlock_unlock(rwlock);
        }

        return val;
}

switch_status_t switch_core_hash_init_case	(	switch_hash_t **	hash,
		switch_memory_pool_t *	pool,
		switch_bool_t	case_sensitive
	)

Definition at line 45 of file switch_core_hash.c.

References switch_assert, switch_core_alloc, SWITCH_STATUS_SUCCESS, switch_zmalloc, and switch_hash::table.

{
        switch_hash_t *newhash;

        if (pool) {
                newhash = switch_core_alloc(pool, sizeof(*newhash));
                newhash->pool = pool;
        } else {
                switch_zmalloc(newhash, sizeof(*newhash));
        }

        switch_assert(newhash);

        sqlite3HashInit(&newhash->table, case_sensitive ? SQLITE_HASH_BINARY : SQLITE_HASH_STRING, 1);
        *hash = newhash;

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_core_hash_insert	(	switch_hash_t *	hash,
		const char *	key,
		const void *	data
	)

Definition at line 78 of file switch_core_hash.c.

References SWITCH_STATUS_SUCCESS.

{
        sqlite3HashInsert(&hash->table, key, (int) strlen(key) + 1, (void *) data);
        return SWITCH_STATUS_SUCCESS;
}

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 84 of file switch_core_hash.c.

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

{
        if (mutex) {
                switch_mutex_lock(mutex);
        }

        sqlite3HashInsert(&hash->table, key, (int) strlen(key) + 1, (void *) data);

        if (mutex) {
                switch_mutex_unlock(mutex);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_hash_index_t* switch_hash_first	(	char *	deprecate_me,
		switch_hash_t *	hash
	)

Definition at line 225 of file switch_core_hash.c.

{
        return (switch_hash_index_t *) sqliteHashFirst(&hash->table);
}

switch_hash_index_t* switch_hash_next

(

switch_hash_index_t *

hi

)

Definition at line 230 of file switch_core_hash.c.

{
        return (switch_hash_index_t *) sqliteHashNext((HashElem *) hi);
}

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

Definition at line 235 of file switch_core_hash.c.

{
        if (key) {
                *key = sqliteHashKey((HashElem *) hi);
                if (klen) {
                        *klen = strlen((char *) *key) + 1;
                }
        }
        if (val) {
                *val = sqliteHashData((HashElem *) hi);
        }
}

---