Shmap API documentation
shmap * shmap_init ( void * p_memsegm, size_t size, int map_type, void * p_opts )
This is the main function to use is. A pointer to newly allocated
hashmap structure is returned or NULL if an error occured.
p_memsegm - the memory segment pointer. useful if you want many hashmaps
to use the same shared memory segment. Currently this is tied with the MM
structure defined in libmm. Set it NULL, if you want a brand new shared memory
segment to be allocated
size - the shared memory segment size. If p_memsegm is NULL, then you have
to specify a number greater than 0. If p_memsegm is not NULL, then this argument
map_type - what type of internal structure to use. Current possible values
are SHMAP_TYPE_LL and SHMAP_TYPE_HM. See internal structures for more information
p_opts - this is for the future. Set it to NULL right now.
void * shmap_get_value ( shmap * map, const char * key, int cached )
This function returns a hashmap value based on the given key.
map - the hashmap pointer
key - the key string pointer. Lookup is done based on that.
cached - specify 0 if you want to bypass any kind of lookup cachings or
1 if it is ok when the result is returned from cache. The thing is, that sometimes
caching might not work and wrong answer is returned. IF this happens, then
you should specify cached = 0. If wrong answer is still displayed, then look
for the error elsewhere.
char * shmap_get ( shmap * map, const char * key )
This functions is merely an alias to shmap_get_value. The
difference is, that you don't have to cast void * into char * and caching
is turned on by default.
int shmap_get_int ( shmap * map, const char * key, int *p_error, int cached )
Instead or void * (or char *, like ine shmap_get) like in
shmap_get_value, int type of data is returned.
map - the hashmap itself where we do the lookup based on key
key - the key for the value we are looking for
*p_error - pointer to int datatype. If an error happened during the lookup,
then 0 is stored to the pointer, if everything is successful, then 1 is stored.
cached - 0 to bypass any kind of lookup caching, 1 to use caching
Return: the integer value for the given key.
int shmap_add_value ( shmap * map, const char * key, const char * value )
Adds or replaces an existing entry in the map. If the given
key already exists, then the value is replaced, otherwise it is inserted.
map - the hashmap that we want to use for adding or replacing.
key - the key to store value under.
value - the value that we want to store into hashmap
Return: 0 if error occured, 1 if everything is a successful
int shmap_add ( shmap * map, const char * key, const char * value )
This is merely an alias to shmap_add_value.
int shmap_del_value ( shmap * map, const char * key )
Deletes a key and its representing value from hashmap
map - the hashmap we want to modify
key - the key we want to remove from hashmap
Return: 1 if hashmap entry was deleted, 0 if an error occured or the entry
did not exist.
char * shmap_get_sub ( shmap * map, const char * key, int keylen, int pos, int cached )
Returns a key value from hashmap based on the subkey.
Example: if key is "IP_ADDRESS", keylen is 2 and pos is 0, then the FIRST
full name of a key is returned, that starts with string "IP"
int shmap_del_sub ( shmap * map, const char * key, int keylen )
Deletes all values that start with key first
map - the hashmap we want to clear of some keys
key - the key name used upon deletion
keylen - key length used is strncmp
Return 1 if success, 0 if error occured
int shmap_clear ( shmap * map )
Deletes all values from map
int shmap_dispose ( shmap * map )
Deletes the whole map. You can not use
it after this point or bad things will start to happen
void shmap_empty_cache ( shmap * map )
If internal caching is used, then this
function will flush the cache. Sometimes it is necessary.
void * shmap_memsegm ( shmap * map )
Returns the memory segment pointer
used within hashmap map.
unsigned int shmap_items ( shmap * map )
Returns the amount of items in hashmap
unsigned int shmap_available ( shmap * map )
Returns the amount of memory available
for hashmap map.