This commit is contained in:
439
ase/lib/cmn/map.c
Normal file
439
ase/lib/cmn/map.c
Normal file
@ -0,0 +1,439 @@
|
||||
/*
|
||||
* $Id: map.c 156 2008-03-22 12:09:35Z baconevi $
|
||||
*
|
||||
* {License}
|
||||
*/
|
||||
|
||||
#include <ase/cmn/map.h>
|
||||
#include <ase/cmn/str.h>
|
||||
|
||||
static ase_size_t hashkey (const ase_char_t* keyptr, ase_size_t keylen);
|
||||
static int rehash (ase_map_t* map);
|
||||
|
||||
#define FREE_PAIR(map,pair) \
|
||||
do { \
|
||||
if ((map)->freeval != ASE_NULL) \
|
||||
(map)->freeval ((map)->owner, ASE_PAIR_VAL(pair)); \
|
||||
ASE_FREE ((map)->mmgr, pair); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
#define RECYCLE_PAIR(map,pair) \
|
||||
do { \
|
||||
if ((map)->freeval != ASE_NULL) \
|
||||
(map)->freeval ((map)->owner, ASE_PAIR_VAL(pair)); \
|
||||
(pair)->next = (map)->fp; \
|
||||
(map)->fp = (pair); \
|
||||
} while (0)
|
||||
*/
|
||||
|
||||
ase_map_t* ase_map_open (
|
||||
void* owner, ase_size_t capa, unsigned int factor,
|
||||
void(*freeval)(void*,void*), void(*sameval)(void*,void*),
|
||||
ase_mmgr_t* mmgr)
|
||||
{
|
||||
ase_map_t* map;
|
||||
|
||||
ASE_ASSERTX (capa > 0, "the initial capacity should be greater than 0");
|
||||
|
||||
map = (ase_map_t*) ASE_MALLOC (mmgr, ASE_SIZEOF(ase_map_t));
|
||||
if (map == ASE_NULL) return ASE_NULL;
|
||||
|
||||
map->mmgr = mmgr;
|
||||
map->buck = (ase_pair_t**)
|
||||
ASE_MALLOC (mmgr, ASE_SIZEOF(ase_pair_t*)*capa);
|
||||
if (map->buck == ASE_NULL)
|
||||
{
|
||||
ASE_FREE (mmgr, map);
|
||||
return ASE_NULL;
|
||||
}
|
||||
|
||||
map->owner = owner;
|
||||
map->capa = capa;
|
||||
map->size = 0;
|
||||
map->freeval = freeval;
|
||||
map->sameval = sameval;
|
||||
while (capa > 0) map->buck[--capa] = ASE_NULL;
|
||||
|
||||
map->factor = factor;
|
||||
map->threshold = ((ase_size_t)map->factor) * map->capa / 100;
|
||||
|
||||
/*map->fp = ASE_NULL;*/
|
||||
return map;
|
||||
}
|
||||
|
||||
void ase_map_close (ase_map_t* map)
|
||||
{
|
||||
ase_map_clear (map);
|
||||
ASE_FREE (map->mmgr, map->buck);
|
||||
ASE_FREE (map->mmgr, map);
|
||||
}
|
||||
|
||||
void ase_map_clear (ase_map_t* map)
|
||||
{
|
||||
ase_size_t i;
|
||||
ase_pair_t* pair, * next;
|
||||
|
||||
/*
|
||||
while (map->fp != ASE_NULL)
|
||||
{
|
||||
next = ASE_PAIR_LNK(map->fp);
|
||||
ASE_FREE (map->mmgr, map->fp);
|
||||
map->fp = next;
|
||||
}
|
||||
*/
|
||||
|
||||
for (i = 0; i < map->capa; i++)
|
||||
{
|
||||
pair = map->buck[i];
|
||||
|
||||
while (pair != ASE_NULL)
|
||||
{
|
||||
next = ASE_PAIR_LNK(pair);
|
||||
FREE_PAIR (map, pair);
|
||||
map->size--;
|
||||
pair = next;
|
||||
}
|
||||
|
||||
map->buck[i] = ASE_NULL;
|
||||
}
|
||||
}
|
||||
|
||||
ase_size_t ase_map_getsize (ase_map_t* map)
|
||||
{
|
||||
return map->size;
|
||||
}
|
||||
|
||||
ase_pair_t* ase_map_get (
|
||||
ase_map_t* map, const ase_char_t* keyptr, ase_size_t keylen)
|
||||
{
|
||||
ase_pair_t* pair;
|
||||
ase_size_t hc;
|
||||
|
||||
hc = hashkey(keyptr,keylen) % map->capa;
|
||||
pair = map->buck[hc];
|
||||
|
||||
while (pair != ASE_NULL)
|
||||
{
|
||||
if (ase_strxncmp (
|
||||
ASE_PAIR_KEYPTR(pair), ASE_PAIR_KEYLEN(pair),
|
||||
keyptr, keylen) == 0) return pair;
|
||||
|
||||
pair = ASE_PAIR_LNK(pair);
|
||||
}
|
||||
|
||||
return ASE_NULL;
|
||||
}
|
||||
|
||||
ase_pair_t* ase_map_put (
|
||||
ase_map_t* map, const ase_char_t* keyptr, ase_size_t keylen, void* val)
|
||||
{
|
||||
int n;
|
||||
ase_pair_t* px;
|
||||
|
||||
n = ase_map_putx (map, keyptr, keylen, val, &px);
|
||||
if (n < 0) return ASE_NULL;
|
||||
return px;
|
||||
}
|
||||
|
||||
int ase_map_putx (
|
||||
ase_map_t* map, const ase_char_t* keyptr, ase_size_t keylen,
|
||||
void* val, ase_pair_t** px)
|
||||
{
|
||||
ase_pair_t* pair, * fp, * fp2;
|
||||
ase_size_t hc;
|
||||
|
||||
hc = hashkey(keyptr,keylen) % map->capa;
|
||||
pair = map->buck[hc];
|
||||
|
||||
while (pair != ASE_NULL)
|
||||
{
|
||||
if (ase_strxncmp (
|
||||
ASE_PAIR_KEYPTR(pair), ASE_PAIR_KEYLEN(pair),
|
||||
keyptr, keylen) == 0)
|
||||
{
|
||||
if (px != ASE_NULL)
|
||||
*px = ase_map_setpair (map, pair, val);
|
||||
else
|
||||
ase_map_setpair (map, pair, val);
|
||||
|
||||
return 0; /* value changed for the existing key */
|
||||
}
|
||||
pair = ASE_PAIR_LNK(pair);
|
||||
}
|
||||
|
||||
if (map->threshold > 0 &&
|
||||
map->size >= map->threshold)
|
||||
{
|
||||
if (rehash(map) == 0) /* ignore the rehash error */
|
||||
{
|
||||
hc = hashkey(keyptr,keylen) % map->capa;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ASE_ASSERT (pair == ASE_NULL);
|
||||
|
||||
/*
|
||||
fp = map->fp; fp2 = ASE_NULL;
|
||||
while (fp != ASE_NULL)
|
||||
{
|
||||
if (fp->key.len == keylen)
|
||||
{
|
||||
pair = fp;
|
||||
if (fp2 == ASE_NULL) map->fp = fp->next;
|
||||
else fp2->next = fp->next;
|
||||
break;
|
||||
}
|
||||
|
||||
fp2 = fp;
|
||||
fp = fp->next;
|
||||
}
|
||||
|
||||
if (pair == ASE_NULL)
|
||||
{
|
||||
*/
|
||||
pair = (ase_pair_t*) ASE_MALLOC (map->mmgr,
|
||||
ASE_SIZEOF(ase_pair_t) + ((keylen+1)*ASE_SIZEOF(*keyptr)));
|
||||
if (pair == ASE_NULL) return -1; /* error */
|
||||
/*}*/
|
||||
|
||||
/* duplicate the key if it is new */
|
||||
ASE_PAIR_KEYPTR(pair) = (ase_char_t*)(pair + 1);
|
||||
ase_strncpy (ASE_PAIR_KEYPTR(pair), keyptr, keylen);
|
||||
|
||||
ASE_PAIR_KEYLEN(pair) = keylen;
|
||||
ASE_PAIR_VAL(pair) = val;
|
||||
ASE_PAIR_LNK(pair) = map->buck[hc];
|
||||
map->buck[hc] = pair;
|
||||
map->size++;
|
||||
|
||||
if (px != ASE_NULL) *px = pair;
|
||||
return 1; /* new key added */
|
||||
}
|
||||
|
||||
ase_pair_t* ase_map_set (
|
||||
ase_map_t* map, const ase_char_t* keyptr, ase_size_t keylen,
|
||||
void* val)
|
||||
{
|
||||
ase_pair_t* pair;
|
||||
ase_size_t hc;
|
||||
|
||||
hc = hashkey(keyptr,keylen) % map->capa;
|
||||
pair = map->buck[hc];
|
||||
|
||||
while (pair != ASE_NULL)
|
||||
{
|
||||
if (ase_strxncmp (
|
||||
ASE_PAIR_KEYPTR(pair), ASE_PAIR_KEYLEN(pair),
|
||||
keyptr, keylen) == 0)
|
||||
{
|
||||
return ase_map_setpair (map, pair, val);
|
||||
}
|
||||
pair = ASE_PAIR_LNK(pair);
|
||||
}
|
||||
|
||||
return ASE_NULL;
|
||||
}
|
||||
|
||||
ase_pair_t* ase_map_getpair (
|
||||
ase_map_t* map, const ase_char_t* keyptr, ase_size_t keylen,
|
||||
void** val)
|
||||
{
|
||||
ase_pair_t* pair;
|
||||
|
||||
pair = ase_map_get (map, keyptr, keylen);
|
||||
if (pair == ASE_NULL) return ASE_NULL;
|
||||
*val = ASE_PAIR_VAL(pair);
|
||||
|
||||
return pair;
|
||||
}
|
||||
|
||||
ase_pair_t* ase_map_setpair (ase_map_t* map, ase_pair_t* pair, void* val)
|
||||
{
|
||||
/* use this function with care */
|
||||
if (ASE_PAIR_VAL(pair) == val)
|
||||
{
|
||||
/* if the old value and the new value are the same,
|
||||
* it just calls the handler for this condition.
|
||||
* No value replacement occurs. */
|
||||
if (map->sameval != ASE_NULL)
|
||||
{
|
||||
map->sameval (map->owner, val);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* frees the old value */
|
||||
if (map->freeval != ASE_NULL)
|
||||
{
|
||||
map->freeval (map->owner, ASE_PAIR_VAL(pair));
|
||||
}
|
||||
|
||||
/* the new value takes the place */
|
||||
ASE_PAIR_VAL(pair) = val;
|
||||
}
|
||||
|
||||
|
||||
return pair;
|
||||
}
|
||||
|
||||
int ase_map_remove (
|
||||
ase_map_t* map, const ase_char_t* keyptr, ase_size_t keylen)
|
||||
{
|
||||
ase_pair_t* pair, * prev;
|
||||
ase_size_t hc;
|
||||
|
||||
hc = hashkey(keyptr,keylen) % map->capa;
|
||||
pair = map->buck[hc];
|
||||
prev = ASE_NULL;
|
||||
|
||||
while (pair != ASE_NULL)
|
||||
{
|
||||
if (ase_strxncmp (
|
||||
ASE_PAIR_KEYPTR(pair), ASE_PAIR_KEYLEN(pair),
|
||||
keyptr, keylen) == 0)
|
||||
{
|
||||
if (prev == ASE_NULL)
|
||||
map->buck[hc] = ASE_PAIR_LNK(pair);
|
||||
else ASE_PAIR_LNK(prev) = ASE_PAIR_LNK(pair);
|
||||
|
||||
/*RECYCLE_PAIR (map, pair);*/
|
||||
FREE_PAIR (map, pair);
|
||||
|
||||
map->size--;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
prev = pair;
|
||||
pair = ASE_PAIR_LNK(pair);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int ase_map_walk (ase_map_t* map, int (*walker) (ase_pair_t*,void*), void* arg)
|
||||
{
|
||||
ase_size_t i;
|
||||
ase_pair_t* pair, * next;
|
||||
|
||||
for (i = 0; i < map->capa; i++)
|
||||
{
|
||||
pair = map->buck[i];
|
||||
|
||||
while (pair != ASE_NULL)
|
||||
{
|
||||
next = ASE_PAIR_LNK(pair);
|
||||
if (walker(pair,arg) == -1) return -1;
|
||||
pair = next;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
ase_pair_t* ase_map_getfirstpair (ase_map_t* map, ase_size_t* buckno)
|
||||
{
|
||||
ase_size_t i;
|
||||
ase_pair_t* pair;
|
||||
|
||||
for (i = 0; i < map->capa; i++)
|
||||
{
|
||||
pair = map->buck[i];
|
||||
if (pair != ASE_NULL)
|
||||
{
|
||||
*buckno = i;
|
||||
return pair;
|
||||
}
|
||||
}
|
||||
|
||||
return ASE_NULL;
|
||||
}
|
||||
|
||||
ase_pair_t* ase_map_getnextpair (
|
||||
ase_map_t* map, ase_pair_t* pair, ase_size_t* buckno)
|
||||
{
|
||||
ase_size_t i;
|
||||
ase_pair_t* next;
|
||||
|
||||
next = ASE_PAIR_LNK(pair);
|
||||
if (next != ASE_NULL)
|
||||
{
|
||||
/* no change in bucket number */
|
||||
return next;
|
||||
}
|
||||
|
||||
for (i = (*buckno)+1; i < map->capa; i++)
|
||||
{
|
||||
pair = map->buck[i];
|
||||
if (pair != ASE_NULL)
|
||||
{
|
||||
*buckno = i;
|
||||
return pair;
|
||||
}
|
||||
}
|
||||
|
||||
return ASE_NULL;
|
||||
}
|
||||
|
||||
|
||||
static ase_size_t hashkey (const ase_char_t* keyptr, ase_size_t keylen)
|
||||
{
|
||||
ase_size_t n = 0, i;
|
||||
const ase_char_t* end = keyptr + keylen;
|
||||
|
||||
while (keyptr < end)
|
||||
{
|
||||
ase_byte_t* bp = (ase_byte_t*)keyptr;
|
||||
for (i = 0; i < ASE_SIZEOF(*keyptr); i++) n = n * 31 + *bp++;
|
||||
keyptr++;
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
static int rehash (ase_map_t* map)
|
||||
{
|
||||
ase_size_t i, hc, new_capa;
|
||||
ase_pair_t** new_buck;
|
||||
|
||||
new_capa = (map->capa >= 65536)? (map->capa + 65536): (map->capa << 1);
|
||||
|
||||
new_buck = (ase_pair_t**) ASE_MALLOC (
|
||||
map->mmgr, ASE_SIZEOF(ase_pair_t*) * new_capa);
|
||||
if (new_buck == ASE_NULL)
|
||||
{
|
||||
/* once rehash fails, the rehashing is disabled */
|
||||
map->threshold = 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (i = 0; i < new_capa; i++) new_buck[i] = ASE_NULL;
|
||||
|
||||
for (i = 0; i < map->capa; i++)
|
||||
{
|
||||
ase_pair_t* pair = map->buck[i];
|
||||
|
||||
while (pair != ASE_NULL)
|
||||
{
|
||||
ase_pair_t* next = ASE_PAIR_LNK(pair);
|
||||
|
||||
hc = hashkey(
|
||||
ASE_PAIR_KEYPTR(pair),
|
||||
ASE_PAIR_KEYLEN(pair)) % new_capa;
|
||||
|
||||
ASE_PAIR_LNK(pair) = new_buck[hc];
|
||||
new_buck[hc] = pair;
|
||||
|
||||
pair = next;
|
||||
}
|
||||
}
|
||||
|
||||
ASE_FREE (map->mmgr, map->buck);
|
||||
map->buck = new_buck;
|
||||
map->capa = new_capa;
|
||||
map->threshold = ((ase_size_t)map->factor) * map->capa / 100;
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user