hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

oh my lda!

Browse Source
This commit is contained in:
hyung-hwan 2008-10-10 05:45:49 +00:00
parent dd2d9190c0
commit b2d1b51302
3 changed files with 213 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
ase/include/ase/cmn/lda.h
View File

@ -10,11 +10,6 @@
#include <ase/types.h>
#include <ase/macros.h>
enum ase_lda_opt_t
{
ASE_LDA_NODLEN = (((ase_uint4_t)1) << 16)
};
/****o* ase.cmn.lda/linear dynamic array
* DESCRIPTION
* <ase/cmn/lda.h> provides a linear dynamic array. It grows as more items
@ -25,25 +20,26 @@ enum ase_lda_opt_t
*/
typedef struct ase_lda_t ase_lda_t;
typedef struct ase_lda_cell_t ase_lda_cell_t;
typedef struct ase_lda_node_t ase_lda_node_t;
#define ASE_LDA_COPIER_SIMPLE ase_lda_copysimple
#define ASE_LDA_COPIER_INLINE ase_lda_copyinline
#define ASE_LDA_INVALID ((ase_size_t)-1)
#define ASE_LDA_SIZE(lda) ((lda)->size)
#define ASE_LDA_CAPA(lda) ((lda)->capa)
#define ASE_LDA_CELL(lda,index) ((lda)->cell[index])
#define ASE_LDA_SIZE(lda) ((lda)->size)
#define ASE_LDA_CAPA(lda) ((lda)->capa)
#define ASE_LDA_DPTR(cell) ((cell)->dptr)
#define ASE_LDA_DLEN(cell) ((cell)->dlen)
#define ASE_LDA_NODE(lda,index) ((lda)->node[index])
#define ASE_LDA_DPTR(lda,index) ((lda)->node[index]->dptr)
#define ASE_LDA_DLEN(lda,index) ((lda)->node[index]->dlen)
#define ASE_LDA_MMGR(lda) ((lda)->mmgr)
#define ASE_LDA_COPIER(lda) ((lda)->copier)
#define ASE_LDA_FREEER(lda) ((lda)->freeer)
#define ASE_LDA_COMPER(lda) ((lda)->comper)
#define ASE_LDA_SIZER(lda) ((lda)->sizer)
#define ASE_LDA_MMGR(lda) ((lda)->mmgr)
#define ASE_LDA_COPIER(lda) ((lda)->copier)
#define ASE_LDA_FREEER(lda) ((lda)->freeer)
#define ASE_LDA_COMPER(lda) ((lda)->comper)
#define ASE_LDA_KEEPER(lda) ((lda)->keeper)
#define ASE_LDA_SIZER(lda) ((lda)->sizer)
/****b* ase.cmn.lda/ase_lda_copier_t
@ -110,6 +106,25 @@ typedef int (*ase_lda_comper_t) (
);
/******/
/****t* ase.cmn.lda/ase_lda_keeper_t
* NAME
* ase_lda_keeper_t - define a value keeper
*
* DESCRIPTION
* The ase_lda_keeper_t type defines a value keeper that is called when
* a value is retained in the context that it should be destroyed because
* it is identical to a new value. Two values are identical if their beginning
* pointers and their lengths are equal.
*
* SYNOPSIS
*/
typedef void (*ase_lda_keeper_t) (
ase_lda_t* lda /* a lda */,
void* vptr /* the pointer to a value */,
ase_size_t vlen /* the length of a value */
);
/******/
/****t* ase.cmn.lda/ase_lda_sizer_t
* NAME
* ase_lda_sizer_t - define an array size calculator
@ -140,26 +155,22 @@ struct ase_lda_t
ase_lda_copier_t copier; /* data copier */
ase_lda_freeer_t freeer; /* data freeer */
ase_lda_comper_t comper; /* data comparator */
ase_lda_keeper_t keeper; /* data keeper */
ase_lda_sizer_t sizer; /* size calculator */
ase_byte_t scale; /* scale factor */
ase_uint16_t opt;
ase_size_t size; /* the number of items */
ase_size_t capa; /* capacity */
/*ase_lda_cell_t** cell;*/
void* cell;
ase_lda_node_t** node;
};
/******/
/****s*
* NAME
* ase_lda_cell_t - define a linear dynamic array cell
* ase_lda_node_t - define a linear dynamic array node
*
* SYNOPSIS
*/
struct ase_lda_cell_t
struct ase_lda_node_t
{
void* dptr;
ase_size_t dlen;
@ -179,8 +190,7 @@ extern "C" {
ase_lda_t* ase_lda_open (
ase_mmgr_t* lda,
ase_size_t ext,
ase_size_t capa,
ase_uint4_t opt
ase_size_t capa
);
/******/
@ -202,9 +212,9 @@ void ase_lda_close (
* SYNOPSIS
*/
ase_lda_t* ase_lda_init (
ase_lda_t* lda,
ase_lda_t* lda,
ase_mmgr_t* mmgr,
ase_size_t capa
ase_size_t capa
);
/******/
@ -360,10 +370,31 @@ ase_size_t ase_lda_rsearch (
ase_size_t dlen
);
ase_size_t ase_lda_rrsearch (
ase_lda_t* lda,
ase_size_t pos,
const void* dptr,
ase_size_t dlen
);
ase_size_t ase_lda_upsert (
ase_lda_t* lda,
ase_size_t index,
void* dptr,
ase_size_t dlen
);
ase_size_t ase_lda_insert (
ase_lda_t* lda,
ase_size_t index,
void* dptr,
void* dptr,
ase_size_t dlen
);
ase_size_t ase_lda_update (
ase_lda_t* lda,
ase_size_t pos,
void* dptr,
ase_size_t dlen
);

38
ase/include/ase/cmn/map.h
View File

@ -1,5 +1,5 @@
/*
* $Id: map.h 409 2008-10-08 11:43:56Z baconevi $
* $Id: map.h 413 2008-10-09 11:45:49Z baconevi $
*
* {License}
*/
@ -110,7 +110,7 @@ typedef int (*ase_map_comper_t) (
*/
typedef void (*ase_map_keeper_t) (
ase_map_t* map /* a map */,
void* vptr /* the pointer to a value */,
void* vptr /* the pointer to a value */,
ase_size_t vlen /* the length of a value */
);
/******/
@ -139,9 +139,9 @@ typedef ase_size_t (*ase_map_sizer_t) (
* SYNOPSIS
*/
typedef ase_map_walk_t (*ase_map_walker_t) (
ase_map_t* map /* a map */,
ase_map_t* map /* a map */,
ase_map_pair_t* pair /* the pointer to a key/value pair */,
void* arg /* the pointer to user-defined data */
void* arg /* the pointer to user-defined data */
);
/******/
@ -162,13 +162,11 @@ typedef ase_map_walk_t (*ase_map_walker_t) (
*/
struct ase_map_pair_t
{
void* kptr; /* the pointer to a key */
ase_size_t klen; /* the length of a key */
void* vptr; /* the pointer to a value */
ase_size_t vlen; /* the length of a value */
ase_map_pair_t* next; /* the next pair under the same slot */
void* kptr; /* the pointer to a key */
ase_size_t klen; /* the length of a key */
void* vptr; /* the pointer to a value */
ase_size_t vlen; /* the length of a value */
ase_map_pair_t* next; /* the next pair under the same slot */
};
/*****/
@ -180,23 +178,19 @@ struct ase_map_pair_t
*/
struct ase_map_t
{
ase_mmgr_t* mmgr;
ase_mmgr_t* mmgr;
ase_map_copier_t copier[2];
ase_map_freeer_t freeer[2];
ase_map_hasher_t hasher; /* key hasher */
ase_map_comper_t comper; /* key comparator */
ase_map_keeper_t keeper; /* value keeper */
ase_map_sizer_t sizer; /* bucket capacity recalculator */
ase_byte_t scale[2]; /* length scale */
ase_byte_t factor; /* load factor */
ase_byte_t filler0;
ase_size_t size;
ase_size_t capa;
ase_size_t threshold;
ase_byte_t scale[2]; /* length scale */
ase_byte_t factor; /* load factor */
ase_byte_t filler0;
ase_size_t size;
ase_size_t capa;
ase_size_t threshold;
ase_map_pair_t** bucket;
};
/******/

208
ase/lib/cmn/lda.c
View File

@ -8,7 +8,7 @@
#include "mem.h"
#define lda_t ase_lda_t
#define cell_t ase_lda_cell_t
#define node_t ase_lda_node_t
#define copier_t ase_lda_copier_t
#define freeer_t ase_lda_freeer_t
#define comper_t ase_lda_comper_t
@ -17,18 +17,12 @@
#define mmgr_t ase_mmgr_t
#define size_t ase_size_t
#define uint4_t ase_uint4_t
#define TOB(lda,len) ((len)*(lda)->scale)
#define DPTR(cell) ASE_LDA_DPTR(cell)
#define DLEN(cell) ASE_LDA_DLEN(cell)
#define DPTR(node) ((node)->dptr)
#define DLEN(node) ((node)->dlen)
#define INVALID ASE_LDA_INVALID
/* get cell size */
#define CS(lda) ((lda)->opt & 0xFFFF)
/* check if the option is set */
#define OPT(lda,o) ((lda)->opt & (o))
static int comp_data (lda_t* lda,
const void* dptr1, size_t dlen1,
const void* dptr2, size_t dlen2)
@ -48,20 +42,20 @@ static int comp_data (lda_t* lda,
return n;
}
static cell_t* alloc_cell (lda_t* lda, void* dptr, size_t dlen)
static node_t* alloc_node (lda_t* lda, void* dptr, size_t dlen)
{
cell_t* n;
node_t* n;
if (lda->copier == ASE_LDA_COPIER_SIMPLE)
{
n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(cell_t));
n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(node_t));
if (n == ASE_NULL) return ASE_NULL;
DPTR(n) = dptr;
}
else if (lda->copier == ASE_LDA_COPIER_INLINE)
{
n = ASE_MMGR_ALLOC (lda->mmgr,
ASE_SIZEOF(cell_t) + TOB(lda,dlen));
ASE_SIZEOF(node_t) + TOB(lda,dlen));
if (n == ASE_NULL) return ASE_NULL;
ASE_MEMCPY (n + 1, dptr, TOB(lda,dlen));
@ -69,7 +63,7 @@ static cell_t* alloc_cell (lda_t* lda, void* dptr, size_t dlen)
}
else
{
n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(cell_t));
n = ASE_MMGR_ALLOC (lda->mmgr, ASE_SIZEOF(node_t));
if (n == ASE_NULL) return ASE_NULL;
DPTR(n) = lda->copier (lda, dptr, dlen);
if (DPTR(n) == ASE_NULL)
@ -84,7 +78,7 @@ static cell_t* alloc_cell (lda_t* lda, void* dptr, size_t dlen)
return n;
}
lda_t* ase_lda_open (mmgr_t* mmgr, size_t ext, size_t capa, uint4_t opt)
lda_t* ase_lda_open (mmgr_t* mmgr, size_t ext, size_t capa)
{
lda_t* lda;
@ -101,7 +95,7 @@ lda_t* ase_lda_open (mmgr_t* mmgr, size_t ext, size_t capa, uint4_t opt)
lda = ASE_MMGR_ALLOC (mmgr, ASE_SIZEOF(lda_t) + ext);
if (lda == ASE_NULL) return ASE_NULL;
return ase_lda_init (lda, mmgr, capa, opt);
return ase_lda_init (lda, mmgr, capa);
}
void ase_lda_close (lda_t* lda)
@ -110,15 +104,14 @@ void ase_lda_close (lda_t* lda)
ASE_MMGR_FREE (lda->mmgr, lda);
}
lda_t* ase_lda_init (lda_t* lda, mmgr_t* mmgr, size_t capa, uint4_t opt)
lda_t* ase_lda_init (lda_t* lda, mmgr_t* mmgr, size_t capa)
{
ASE_MEMSET (lda, 0, ASE_SIZEOF(*lda));
lda->mmgr = mmgr;
lda->size = 0;
lda->capa = 0;
lda->opt = opt;
lda->cell = ASE_NULL;
lda->node = ASE_NULL;
lda->copier = ASE_LDA_COPIER_SIMPLE;
lda->comper = comp_data;
@ -131,10 +124,10 @@ void ase_lda_fini (lda_t* lda)
{
ase_lda_clear (lda);
if (lda->cell != ASE_NULL)
if (lda->node != ASE_NULL)
{
ASE_MMGR_FREE (lda->mmgr, lda->cell);
lda->cell = ASE_NULL;
ASE_MMGR_FREE (lda->mmgr, lda->node);
lda->node = ASE_NULL;
lda->capa = 0;
}
}
@ -234,42 +227,42 @@ lda_t* ase_lda_setcapa (lda_t* lda, size_t capa)
if (capa > 0)
{
if (lda->mmgr->realloc != ASE_NULL)
if (lda->mmgr->realloc != ASE_NULL && lda->node != ASE_NULL)
{
/*tmp = ASE_MMGR_REALLOC (lda->mmgr,
lda->cell, ASE_SIZEOF(*lda->cell) * capa);*/
tmp = ASE_MMGR_REALLOC (lda->mmgr, CS(lda)*capa);
wprintf (L"XXXXXXXXXXXXXXXXXX %d, %d\n", (int)capa, (int)ASE_SIZEOF(*lda->node)*capa);
tmp = (ase_lda_node_t**)ASE_MMGR_REALLOC (
lda->mmgr, lda->node, ASE_SIZEOF(*lda->node)*capa);
if (tmp == ASE_NULL) return ASE_NULL;
}
else
{
/*tmp = ASE_MMGR_ALLOC (
lda->mmgr, ASE_SIZEOF(*lda->cell) * capa);*/
tmp = ASE_MMGR_ALLOC (lda->mmgr, CS(lda)*capa);
wprintf (L"XXXXXXXXXXXXXXXXXX %d, %d\n", (int)capa, (int)ASE_SIZEOF(*lda->node)*capa);
tmp = (ase_lda_node_t**) ASE_MMGR_ALLOC (
lda->mmgr, ASE_SIZEOF(*lda->node)*capa);
if (tmp == ASE_NULL) return ASE_NULL;
if (lda->cell != ASE_NULL)
if (lda->node != ASE_NULL)
{
size_t x;
x = (capa > lda->capa)? lda->capa: capa;
/*ASE_MEMCPY (tmp, lda->cell,
ASE_SIZEOF(*lda->cell) * x);*/
ASE_MEMCPY (tmp, lda->cell, CS(lda)*x);
ASE_MMGR_FREE (lda->mmgr, lda->cell);
ASE_MEMCPY (tmp, lda->node,
ASE_SIZEOF(*lda->node) * x);
ASE_MMGR_FREE (lda->mmgr, lda->node);
}
}
}
else
{
if (lda->cell != ASE_NULL)
if (lda->node != ASE_NULL)
{
ase_lda_clear (lda);
ASE_MMGR_FREE (lda->mmgr, lda->cell);
ASE_MMGR_FREE (lda->mmgr, lda->node);
}
tmp = ASE_NULL;
}
lda->cell = tmp;
lda->node = tmp;
lda->capa = capa;
return lda;
@ -281,8 +274,8 @@ size_t ase_lda_search (lda_t* lda, size_t pos, const void* dptr, size_t dlen)
for (i = pos; i < lda->size; i++)
{
if (lda->comper(lda,
DPTR(lda->cell[i]), DLEN(lda->cell[i]),
if (lda->comper (lda,
DPTR(lda->node[i]), DLEN(lda->node[i]),
dptr, dlen) == 0) return i;
}
@ -297,8 +290,8 @@ size_t ase_lda_rsearch (lda_t* lda, size_t pos, const void* dptr, size_t dlen)
for (i = pos + 1; i-- > 0; )
{
if (lda->comper(lda,
DPTR(lda->cell[i]), DLEN(lda->cell[i]),
if (lda->comper (lda,
DPTR(lda->node[i]), DLEN(lda->node[i]),
dptr, dlen) == 0) return i;
}
@ -313,43 +306,79 @@ size_t ase_lda_rrsearch (lda_t* lda, size_t pos, const void* dptr, size_t dlen)
for (i = lda->size - pos; i-- > 0; )
{
if (lda->comper(lda,
DPTR(lda->cell[i]), DLEN(lda->cell[i]),
if (lda->comper (lda,
DPTR(lda->node[i]), DLEN(lda->node[i]),
dptr, dlen) == 0) return i;
}
return INVALID;
}
size_t ase_lda_upsert (lda_t* lda, size_t pos, void* dptr, size_t dlen)
{
if (pos < lda->size) return ase_lda_update (lda, pos, dptr, dlen);
return ase_lda_insert (lda, pos, dptr, dlen);
}
size_t ase_lda_insert (lda_t* lda, size_t pos, void* dptr, size_t dlen)
{
size_t i;
cell_t* cell;
node_t* node;
cell = alloc_cell (lda, dptr, dlen);
if (cell == ASE_NULL) return INVALID;
/* allocate the node first */
node = alloc_node (lda, dptr, dlen);
if (node == ASE_NULL) return INVALID;
if (pos >= lda->capa)
/* do resizeing if necessary.
* resizing is performed after node allocation because that way, it
* doesn't modify lda on any errors */
if (pos >= lda->capa || lda->size >= lda->capa)
{
size_t capa;
if (lda->capa <= 0) capa = (pos + 1);
else
if (lda->sizer)
{
do { capa = lda->capa * 2; } while (pos >= capa);
capa = (pos >= lda->size)? (pos + 1): (lda->size + 1);
capa = lda->sizer (lda, capa);
}
else
{
if (lda->capa <= 0)
{
ASE_ASSERT (lda->size <= 0);
capa = (pos < 16)? 16: (pos + 1);
}
else
{
size_t bound = (pos >= lda->size)? pos: lda->size;
do { capa = lda->capa * 2; } while (capa <= bound);
}
}
if (ase_lda_setcapa(lda,capa) == ASE_NULL)
{
if (lda->freeer)
lda->freeer (lda, DPTR(cell), DLEN(cell));
lda->freeer (lda, DPTR(node), DLEN(node));
return INVALID;
}
}
for (i = lda->size; i > pos; i--)
lda->cell[i] = lda->cell[i-1];
lda->cell[pos] = cell;
if (pos >= lda->capa)
{
/* the buffer is not still enough after resizing */
if (lda->freeer)
lda->freeer (lda, DPTR(node), DLEN(node));
return INVALID;
}
/* fill in the gap with ASE_NULL */
for (i = lda->size; i < pos; i++) lda->node[i] = ASE_NULL;
/* shift values to the next cell */
for (i = lda->size; i > pos; i--) lda->node[i] = lda->node[i-1];
/* set the value */
lda->node[pos] = node;
if (pos > lda->size) lda->size = pos + 1;
else lda->size++;
@ -357,6 +386,43 @@ size_t ase_lda_insert (lda_t* lda, size_t pos, void* dptr, size_t dlen)
return pos;
}
size_t ase_lda_update (lda_t* lda, size_t pos, void* dptr, size_t dlen)
{
node_t* c;
if (pos >= lda->size) return INVALID;
c = lda->node[pos];
if (c == ASE_NULL)
{
/* no previous data */
lda->node[pos] = alloc_node (lda, dptr, dlen);
if (lda->node[pos] == ASE_NULL) return INVALID;
}
else
{
if (dptr == DPTR(c) && dlen == DLEN(c))
{
/* updated to the same data */
lda->keeper (lda, dptr, dlen);
}
else
{
/* updated to different data */
node_t* node = alloc_node (lda, dptr, dlen);
if (node == ASE_NULL) return INVALID;
if (lda->freeer != ASE_NULL)
lda->freeer (lda, DPTR(c), DLEN(c));
ASE_MMGR_FREE (lda->mmgr, c);
lda->node[pos] = node;
}
}
return pos;
}
size_t ase_lda_delete (lda_t* lda, size_t index, size_t count)
{
size_t i, j, k;
@ -370,7 +436,7 @@ size_t ase_lda_delete (lda_t* lda, size_t index, size_t count)
while (i < k)
{
cell_t* c = lda->cell[i];
node_t* c = lda->node[i];
if (lda->freeer != ASE_NULL)
lda->freeer (lda, DPTR(c), DLEN(c));
@ -378,12 +444,12 @@ size_t ase_lda_delete (lda_t* lda, size_t index, size_t count)
if (j >= lda->size)
{
lda->cell[i] = ASE_NULL;
lda->node[i] = ASE_NULL;
i++;
}
else
{
lda->cell[i] = lda->cell[j];
lda->node[i] = lda->node[j];
i++; j++;
}
}
@ -398,11 +464,11 @@ void ase_lda_clear (lda_t* lda)
for (i = 0; i < lda->size; i++)
{
cell_t* c = lda->cell[i];
if (lda->freeer)
node_t* c = lda->node[i];
if (c && lda->freeer)
lda->freeer (lda, DPTR(c), DLEN(c));
ASE_MMGR_FREE (lda->mmgr, c);
lda->cell[i] = ASE_NULL;
lda->node[i] = ASE_NULL;
}
lda->size = 0;
@ -433,7 +499,7 @@ size_t ase_lda_find (lda_t* lda, size_t index, const ase_char_t* str, size_t len
for (i = index; i < lda->size; i++)
{
if (ase_strxncmp (
lda->cell[i].name.ptr, lda->cell[i].name.len,
lda->node[i].name.ptr, lda->node[i].name.len,
str, len) == 0) return i;
}
@ -449,7 +515,7 @@ size_t ase_lda_rfind (lda_t* lda, size_t index, const ase_char_t* str, size_t le
for (i = index + 1; i-- > 0; )
{
if (ase_strxncmp (
lda->cell[i].name.ptr, lda->cell[i].name.len,
lda->node[i].name.ptr, lda->node[i].name.len,
str, len) == 0) return i;
}
@ -465,7 +531,7 @@ size_t ase_lda_rrfind (lda_t* lda, size_t index, const ase_char_t* str, size_t l
for (i = lda->size - index; i-- > 0; )
{
if (ase_strxncmp (
lda->cell[i].name.ptr, lda->cell[i].name.len,
lda->node[i].name.ptr, lda->node[i].name.len,
str, len) == 0) return i;
}
@ -483,8 +549,8 @@ size_t ase_lda_findx (
{
ase_cstr_t x;
x.ptr = lda->cell[i].name.ptr;
x.len = lda->cell[i].name.len;
x.ptr = lda->node[i].name.ptr;
x.len = lda->node[i].name.len;
transform (i, &x, arg);
if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i;
@ -506,8 +572,8 @@ size_t ase_lda_rfindx (
{
ase_cstr_t x;
x.ptr = lda->cell[i].name.ptr;
x.len = lda->cell[i].name.len;
x.ptr = lda->node[i].name.ptr;
x.len = lda->node[i].name.len;
transform (i, &x, arg);
if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i;
@ -529,8 +595,8 @@ size_t ase_lda_rrfindx (
{
ase_cstr_t x;
x.ptr = lda->cell[i].name.ptr;
x.len = lda->cell[i].name.len;
x.ptr = lda->node[i].name.ptr;
x.len = lda->node[i].name.len;
transform (i, &x, arg);
if (ase_strxncmp (x.ptr, x.len, str, len) == 0) return i;