cmHashTbl.h/c : Initial commit.
This commit is contained in:
kevin
parent
f95d93a4f8
commit
9b3aa4c798
464
cmHashTbl.c
Normal file
464
cmHashTbl.c
Normal file
@ -0,0 +1,464 @@
|
|||||||
|
#include "cmGlobal.h"
|
||||||
|
#include "cmFloatTypes.h"
|
||||||
|
#include "cmRpt.h"
|
||||||
|
#include "cmErr.h"
|
||||||
|
#include "cmCtx.h"
|
||||||
|
#include "cmMem.h"
|
||||||
|
#include "cmLinkedHeap.h"
|
||||||
|
#include "cmMallocDebug.h"
|
||||||
|
#include "cmMath.h"
|
||||||
|
#include "cmHashTbl.h"
|
||||||
|
#include "cmText.h"
|
||||||
|
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
kFreeHtFl = 0x01,
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct cmHtValue_str
|
||||||
|
{
|
||||||
|
unsigned flags; // See kXXXHtFl above.
|
||||||
|
unsigned id; // unique id associated with this value
|
||||||
|
void* value; // value blob
|
||||||
|
unsigned byteCnt; // size of value blob in bytes
|
||||||
|
struct cmHtValue_str* link; // cmHtBucket_t.list link
|
||||||
|
} cmHtValue_t;
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
cmHtValue_t* list; // value list
|
||||||
|
cmHtValue_t* avail; // available value slots - formed from cmHashTblRemoved() values.
|
||||||
|
unsigned nextIdx; // next unused index for this bucket
|
||||||
|
} cmHtBucket_t;
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
cmErr_t err;
|
||||||
|
cmLHeapH_t lhH; // memory for hash table buckets, values, value blobs.
|
||||||
|
unsigned bucketCnt; // hash table bucket cnt
|
||||||
|
unsigned linkCnt; // max length of collision list for each bucket
|
||||||
|
unsigned mask; // hash id bucket index mask (masks the MSB's of the hash-id)
|
||||||
|
unsigned maskShift; // shift required to move the lowest 'mask' bit to the LSB.
|
||||||
|
cmHtBucket_t* b; // b[bucketCnt] bucket array
|
||||||
|
} cmHt_t;
|
||||||
|
|
||||||
|
cmHashTblH_t cmHashTblNullHandle = cmSTATIC_NULL_HANDLE;
|
||||||
|
|
||||||
|
#define _cmHtBucketIndex( p, id ) (((id) & (p)->mask) >> (p)->maskShift)
|
||||||
|
|
||||||
|
cmHt_t* _cmHtHandleToPtr( cmHashTblH_t h )
|
||||||
|
{
|
||||||
|
cmHt_t* p = (cmHt_t*)h.h;
|
||||||
|
assert(p!=NULL);
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Return the bucket index portion of the hash id.
|
||||||
|
unsigned _cmHtGenId( cmHt_t* p, const void* v, unsigned byteCnt )
|
||||||
|
{
|
||||||
|
unsigned i,j;
|
||||||
|
const char* cv = v;
|
||||||
|
unsigned h = 0;
|
||||||
|
|
||||||
|
for(i=0,j=3; i<byteCnt; ++i,++j)
|
||||||
|
h += ((unsigned)cv[i]) << ((j&0x3)*8);
|
||||||
|
|
||||||
|
return h & p->mask;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Given an id find the value.
|
||||||
|
cmHtValue_t* _cmHtIdToValue( cmHt_t* p, unsigned id )
|
||||||
|
{
|
||||||
|
if( id == cmInvalidId )
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
unsigned bi = _cmHtBucketIndex(p,id);
|
||||||
|
|
||||||
|
assert(bi < p->bucketCnt);
|
||||||
|
|
||||||
|
cmHtValue_t* v = p->b[bi].list;
|
||||||
|
for(; v!=NULL; v=v->link)
|
||||||
|
if( v->id == id )
|
||||||
|
return v;
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Given a value find the id
|
||||||
|
cmHtValue_t* _cmHtValueToId( cmHt_t* p, const void* value, unsigned byteCnt, unsigned id )
|
||||||
|
{
|
||||||
|
if( id == cmInvalidId )
|
||||||
|
id = _cmHtGenId(p,value,byteCnt);
|
||||||
|
|
||||||
|
unsigned bi = _cmHtBucketIndex(p,id);
|
||||||
|
|
||||||
|
assert(bi < p->bucketCnt);
|
||||||
|
|
||||||
|
cmHtValue_t* v = p->b[bi].list;
|
||||||
|
for(; v!=NULL; v=v->link)
|
||||||
|
if( v->byteCnt==byteCnt && memcmp(value,v->value,byteCnt)==0 )
|
||||||
|
return v;
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
cmHtRC_t _cmHtDestroy( cmHt_t* p )
|
||||||
|
{
|
||||||
|
cmHtRC_t rc = kOkHtRC;
|
||||||
|
cmLHeapDestroy(&p->lhH);
|
||||||
|
cmMemFree(p->b);
|
||||||
|
cmMemFree(p);
|
||||||
|
return rc;
|
||||||
|
}
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblCreate( cmCtx_t* ctx, cmHashTblH_t* hp, unsigned bucketCnt )
|
||||||
|
{
|
||||||
|
cmHtRC_t rc;
|
||||||
|
if((rc = cmHashTblDestroy(hp)) != kOkHtRC )
|
||||||
|
return rc;
|
||||||
|
|
||||||
|
cmHt_t* p = cmMemAllocZ(cmHt_t,1);
|
||||||
|
|
||||||
|
cmErrSetup(&p->err,&ctx->rpt,"hash table");
|
||||||
|
|
||||||
|
if(cmLHeapIsValid(p->lhH = cmLHeapCreate(8192,ctx)) == false )
|
||||||
|
{
|
||||||
|
cmErrMsg(&p->err,kLHeapFailHtRC,"Internal linked heap mgr. create failed.");
|
||||||
|
goto errLabel;
|
||||||
|
}
|
||||||
|
|
||||||
|
// force the bucket count to be a power of two
|
||||||
|
p->bucketCnt = cmNextPowerOfTwo(bucketCnt);
|
||||||
|
p->mask = p->bucketCnt - 1;
|
||||||
|
|
||||||
|
// calcluate the hash-id bucket mask
|
||||||
|
for(p->maskShift=0; (0x80000000 & p->mask) == 0; ++p->maskShift )
|
||||||
|
p->mask <<= 1;
|
||||||
|
|
||||||
|
// calculate the maximum collisions per bucket mask
|
||||||
|
p->linkCnt = ~p->mask;
|
||||||
|
|
||||||
|
// allocate the bucket array
|
||||||
|
p->b = cmMemAllocZ(cmHtBucket_t,p->bucketCnt);
|
||||||
|
|
||||||
|
hp->h = p;
|
||||||
|
|
||||||
|
errLabel:
|
||||||
|
if( rc != kOkHtRC )
|
||||||
|
_cmHtDestroy(p);
|
||||||
|
return rc;
|
||||||
|
}
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblDestroy( cmHashTblH_t* hp )
|
||||||
|
{
|
||||||
|
cmHtRC_t rc = kOkHtRC;
|
||||||
|
if(hp==NULL || cmHashTblIsValid(*hp)==false )
|
||||||
|
return rc;
|
||||||
|
|
||||||
|
cmHt_t* p = _cmHtHandleToPtr(*hp);
|
||||||
|
|
||||||
|
if((rc = _cmHtDestroy(p)) != kOkHtRC )
|
||||||
|
return rc;
|
||||||
|
|
||||||
|
hp->h = NULL;
|
||||||
|
|
||||||
|
return rc;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool cmHashTblIsValid( cmHashTblH_t h )
|
||||||
|
{ return h.h!=NULL; }
|
||||||
|
|
||||||
|
unsigned cmHashTblStoreBase( cmHashTblH_t h, void* v, unsigned byteCnt, bool staticFl )
|
||||||
|
{
|
||||||
|
cmHt_t* p = _cmHtHandleToPtr(h);
|
||||||
|
cmHtValue_t* vp = NULL;
|
||||||
|
unsigned id = _cmHtGenId(p, v, byteCnt );
|
||||||
|
|
||||||
|
// if the value is already stored then there is nothing else to do
|
||||||
|
if((vp = _cmHtValueToId(p,v,byteCnt,id)) != NULL )
|
||||||
|
return vp->id;
|
||||||
|
|
||||||
|
unsigned bi = _cmHtBucketIndex(p,id);
|
||||||
|
|
||||||
|
assert(bi < p->bucketCnt );
|
||||||
|
|
||||||
|
cmHtBucket_t* b = p->b + bi;
|
||||||
|
|
||||||
|
if( b->avail != NULL )
|
||||||
|
{
|
||||||
|
vp = b->avail;
|
||||||
|
b->avail = b->avail->link;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if( b->nextIdx == p->linkCnt || (id + b->nextIdx) == cmInvalidId )
|
||||||
|
{
|
||||||
|
cmErrMsg(&p->err,kHashFaultHtRC,"The hash table bucket at index %i is exhaused.",bi);
|
||||||
|
return cmInvalidId;
|
||||||
|
}
|
||||||
|
|
||||||
|
vp = cmLhAllocZ(p->lhH,cmHtValue_t,1);
|
||||||
|
vp->id = id + b->nextIdx++;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
assert( vp->id != cmInvalidId );
|
||||||
|
|
||||||
|
vp->link = b->list;
|
||||||
|
b->list = vp;
|
||||||
|
vp->byteCnt = byteCnt;
|
||||||
|
|
||||||
|
if( staticFl )
|
||||||
|
vp->value = v;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
vp->value = cmLhAlloc(p->lhH,char,byteCnt);
|
||||||
|
memcpy(vp->value,v,byteCnt);
|
||||||
|
vp->flags = cmSetFlag(vp->flags,kFreeHtFl);
|
||||||
|
}
|
||||||
|
|
||||||
|
return vp->id;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned cmHashTblStore( cmHashTblH_t h, void* v, unsigned byteCnt )
|
||||||
|
{ return cmHashTblStoreBase(h,v,byteCnt,false); }
|
||||||
|
|
||||||
|
unsigned cmHashTblStoreStatic( cmHashTblH_t h, void* v, unsigned byteCnt )
|
||||||
|
{ return cmHashTblStoreBase(h,v,byteCnt,true); }
|
||||||
|
|
||||||
|
unsigned _cmHashTblStoreStr( cmHashTblH_t h, const cmChar_t* s, bool staticFl )
|
||||||
|
{
|
||||||
|
unsigned n = cmTextLength(s);
|
||||||
|
if( n == 0 )
|
||||||
|
{
|
||||||
|
s = "";
|
||||||
|
n = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return cmHashTblStoreBase(h,(void*)s,n+1,staticFl);
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned cmHashTblStoreStr( cmHashTblH_t h, const cmChar_t* s )
|
||||||
|
{ return _cmHashTblStoreStr(h,s,false); }
|
||||||
|
|
||||||
|
unsigned cmhashTblStoreStaticStr( cmHashTblH_t h, const cmChar_t* s )
|
||||||
|
{ return _cmHashTblStoreStr(h,s,true); }
|
||||||
|
|
||||||
|
unsigned cmHashTblStoreV( cmHashTblH_t h, const cmChar_t* fmt, va_list vl )
|
||||||
|
{
|
||||||
|
cmChar_t* s = NULL;
|
||||||
|
s = cmTsVPrintfP(s,fmt,vl);
|
||||||
|
unsigned id = _cmHashTblStoreStr(h,s,false);
|
||||||
|
cmMemFree(s);
|
||||||
|
return id;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned cmHashTblStoreF( cmHashTblH_t h, const cmChar_t* fmt, ... )
|
||||||
|
{
|
||||||
|
va_list vl;
|
||||||
|
va_start(vl,fmt);
|
||||||
|
unsigned id = cmHashTblStoreV(h,fmt,vl);
|
||||||
|
va_end(vl);
|
||||||
|
return id;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned cmHashTblId( cmHashTblH_t h, const void* value, unsigned byteCnt )
|
||||||
|
{
|
||||||
|
cmHt_t* p = _cmHtHandleToPtr(h);
|
||||||
|
cmHtValue_t* vp;
|
||||||
|
|
||||||
|
if((vp = _cmHtValueToId(p,value,byteCnt,cmInvalidId)) == NULL )
|
||||||
|
return cmInvalidId;
|
||||||
|
|
||||||
|
return vp->id;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned cmHashTblStrToId( cmHashTblH_t h, const cmChar_t* str )
|
||||||
|
{
|
||||||
|
if( str == NULL )
|
||||||
|
return cmInvalidId;
|
||||||
|
|
||||||
|
return cmHashTblId(h,str,cmTextLength(str)+1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
const void* cmHashTblValue( cmHashTblH_t h, unsigned id, unsigned* byteCntRef )
|
||||||
|
{
|
||||||
|
cmHt_t* p = _cmHtHandleToPtr(h);
|
||||||
|
cmHtValue_t* vp;
|
||||||
|
|
||||||
|
if((vp = _cmHtIdToValue(p, id)) != NULL )
|
||||||
|
{
|
||||||
|
if( byteCntRef != NULL )
|
||||||
|
*byteCntRef = vp->byteCnt;
|
||||||
|
|
||||||
|
return vp->value;
|
||||||
|
}
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
const cmChar_t* cmHashTblStr( cmHashTblH_t h, unsigned id )
|
||||||
|
{ return (const cmChar_t*)cmHashTblValue(h,id,NULL); }
|
||||||
|
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblRemove( cmHashTblH_t h, unsigned id )
|
||||||
|
{
|
||||||
|
cmHt_t* p = _cmHtHandleToPtr(h);
|
||||||
|
unsigned bi = _cmHtBucketIndex(p,id);
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
assert(bi < p->bucketCnt);
|
||||||
|
|
||||||
|
cmHtBucket_t* b = p->b + bi;
|
||||||
|
|
||||||
|
cmHtValue_t* vp = b->list;
|
||||||
|
cmHtValue_t* pp = NULL;
|
||||||
|
|
||||||
|
for(; vp!=NULL; vp=vp->link)
|
||||||
|
{
|
||||||
|
if( vp->id == id )
|
||||||
|
{
|
||||||
|
if( pp == NULL )
|
||||||
|
b->list = vp->link;
|
||||||
|
else
|
||||||
|
pp->link = vp->link;
|
||||||
|
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
pp = vp;
|
||||||
|
}
|
||||||
|
|
||||||
|
if( vp == NULL )
|
||||||
|
return cmErrMsg(&p->err,kInvalidIdHtRC,"A value could not be found for the hash id 0x%x.",id);
|
||||||
|
|
||||||
|
if( cmIsFlag(vp->flags,kFreeHtFl ) )
|
||||||
|
cmLhFree(p->lhH,vp->value);
|
||||||
|
|
||||||
|
|
||||||
|
vp->flags = 0;
|
||||||
|
vp->value = NULL;
|
||||||
|
vp->byteCnt = 0;
|
||||||
|
|
||||||
|
// Note: Do not set the id to zero since we want to consert id's
|
||||||
|
// and this recd will be reused by the next call to cmHashTblStoreBase().
|
||||||
|
|
||||||
|
return kOkHtRC;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblLastRC( cmHashTblH_t h )
|
||||||
|
{
|
||||||
|
cmHt_t* p = _cmHtHandleToPtr(h);
|
||||||
|
return cmErrLastRC(&p->err);
|
||||||
|
}
|
||||||
|
|
||||||
|
void _cmHashTblBucketReport( cmHtBucket_t* b, cmRpt_t* rpt )
|
||||||
|
{
|
||||||
|
cmHtValue_t* vp = b->list;
|
||||||
|
unsigned i;
|
||||||
|
for(i=0; vp!=NULL && i<10; vp=vp->link,++i)
|
||||||
|
cmRptPrintf(rpt,"0x%x : %s\n",vp->id,((const cmChar_t*)vp->value));
|
||||||
|
|
||||||
|
cmRptPrintf(rpt,"\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
void cmHashTblReport( cmHashTblH_t h, cmRpt_t* rpt )
|
||||||
|
{
|
||||||
|
cmHt_t* p = _cmHtHandleToPtr(h);
|
||||||
|
unsigned i;
|
||||||
|
for(i=0; i<p->bucketCnt; ++i)
|
||||||
|
{
|
||||||
|
//if( p->b[i].nextIdx > 0 )
|
||||||
|
// cmRptPrintf(rpt,"%i,%i\n",i,p->b[i].nextIdx);
|
||||||
|
|
||||||
|
if( p->b[i].nextIdx > 100 )
|
||||||
|
_cmHashTblBucketReport(p->b + i,rpt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblTest( cmCtx_t* ctx )
|
||||||
|
{
|
||||||
|
cmHtRC_t rc = kOkHtRC;
|
||||||
|
cmHashTblH_t h = cmHashTblNullHandle;
|
||||||
|
cmErr_t err;
|
||||||
|
cmErrSetup(&err,&ctx->rpt,"hash table test");
|
||||||
|
|
||||||
|
if((rc = cmHashTblCreate(ctx,&h,8192)) != kOkHtRC )
|
||||||
|
return cmErrMsg(&err,rc,"Hash table create failed.");
|
||||||
|
|
||||||
|
const cmChar_t* arr[] =
|
||||||
|
{
|
||||||
|
"1",
|
||||||
|
"12",
|
||||||
|
"123",
|
||||||
|
"1234",
|
||||||
|
"12345",
|
||||||
|
"123456",
|
||||||
|
"123456",
|
||||||
|
"123456",
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
unsigned n = sizeof(arr)/sizeof(arr[0]);
|
||||||
|
unsigned ids[ n ];
|
||||||
|
int i = 0;
|
||||||
|
|
||||||
|
// store the values from arr[]
|
||||||
|
for(; arr[i]!=NULL; ++i)
|
||||||
|
if((ids[i] = cmHashTblStoreStr(h,arr[i])) == cmInvalidId )
|
||||||
|
{
|
||||||
|
rc = cmErrMsg(&err,cmHashTblLastRC(h),"Hash store failed on: '%s.",cmStringNullGuard(arr[i]));
|
||||||
|
goto errLabel;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
// remove a value
|
||||||
|
unsigned rem_idx = 3;
|
||||||
|
if((rc = cmHashTblRemove(h, ids[rem_idx] )) != kOkHtRC )
|
||||||
|
{
|
||||||
|
rc = cmErrMsg(&err,rc,"Hash removed failed.");
|
||||||
|
goto errLabel;
|
||||||
|
}
|
||||||
|
|
||||||
|
// insert the same value - which should restore the removed value
|
||||||
|
if((ids[rem_idx] = cmHashTblStoreStr(h,arr[rem_idx])) == cmInvalidId )
|
||||||
|
{
|
||||||
|
rc = cmErrMsg(&err,cmHashTblLastRC(h),"Hash store failed on: '%s.",cmStringNullGuard(arr[rem_idx]));
|
||||||
|
goto errLabel;
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
// lookup all the stored values by id
|
||||||
|
for(--i; i>=0; --i)
|
||||||
|
{
|
||||||
|
const cmChar_t* s;
|
||||||
|
|
||||||
|
if((s = cmHashTblStr(h,ids[i])) == NULL )
|
||||||
|
rc = cmErrMsg(&err,kInvalidIdHtRC,"The value associated with hash-id:0x%x could not be found.",ids[i]);
|
||||||
|
else
|
||||||
|
printf("%i : %s\n",i,cmStringNullGuard(s));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
for(i=0; arr[i]!=NULL; ++i)
|
||||||
|
{
|
||||||
|
unsigned id = cmHashTblStrToId(h, arr[i]);
|
||||||
|
printf("%i : 0x%x : %s\n",i, id, cmStringNullGuard(cmHashTblStr(h, id)));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
cmHashTblReport(h, &ctx->rpt );
|
||||||
|
|
||||||
|
|
||||||
|
errLabel:
|
||||||
|
cmHashTblDestroy(&h);
|
||||||
|
return rc;
|
||||||
|
|
||||||
|
}
|
||||||
67
cmHashTbl.h
Normal file
67
cmHashTbl.h
Normal file
@ -0,0 +1,67 @@
|
|||||||
|
#ifndef cmHashTbl_h
|
||||||
|
#define cmHashTbl_h
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
#endif
|
||||||
|
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
kOkHtRC,
|
||||||
|
kLHeapFailHtRC,
|
||||||
|
kHashFaultHtRC,
|
||||||
|
kInvalidIdHtRC
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef cmRC_t cmHtRC_t;
|
||||||
|
typedef cmHandle_t cmHashTblH_t;
|
||||||
|
extern cmHashTblH_t cmHashTblNullHandle;
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblCreate( cmCtx_t* ctx, cmHashTblH_t* hp, unsigned bucketCnt );
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblDestroy( cmHashTblH_t* hp );
|
||||||
|
|
||||||
|
bool cmHashTblIsValid( cmHashTblH_t h );
|
||||||
|
|
||||||
|
// cmhashTblStoreBase() is the canonical store function.
|
||||||
|
// Set 'staticFl' to true if the value does not need to be reallocated
|
||||||
|
// and copied into the internal storage space.
|
||||||
|
// Returns a value which uniquely identifies the value. If a unique
|
||||||
|
// identifier cannot be generated then the function returns cmInvalidId
|
||||||
|
// and sets the hash table error code to kHashFaultRC.
|
||||||
|
unsigned cmHashTblStoreBase( cmHashTblH_t h, void* v, unsigned byteCnt, bool staticFl );
|
||||||
|
|
||||||
|
unsigned cmHashTblStore( cmHashTblH_t h, void* v, unsigned byteCnt );
|
||||||
|
unsigned cmHashTblStoreStatic( cmHashTblH_t h, void* v, unsigned byteCnt );
|
||||||
|
unsigned cmHashTblStoreStr( cmHashTblH_t h, const cmChar_t* s );
|
||||||
|
unsigned cmhashTblStoreStaticStr( cmHashTblH_t h, const cmChar_t* s );
|
||||||
|
unsigned cmHashTblStoreV( cmHashTblH_t h, const cmChar_t* fmt, va_list vl );
|
||||||
|
unsigned cmHashTblStoreF( cmHashTblH_t h, const cmChar_t* fmt, ... );
|
||||||
|
|
||||||
|
// Given a value find an id.
|
||||||
|
unsigned cmHashTblId( cmHashTblH_t h, const void* value, unsigned byteCnt );
|
||||||
|
unsigned cmHashTblStrToId( cmHashTblH_t h, const cmChar_t* str );
|
||||||
|
|
||||||
|
// Returns NULL if no value is associated with 'id'.
|
||||||
|
// 'byteCntRef' is optional.
|
||||||
|
const void* cmHashTblValue( cmHashTblH_t h, unsigned id, unsigned* byteCntRef );
|
||||||
|
|
||||||
|
// Wrapper around cmHashTblValue() which assumes that the stored value is a
|
||||||
|
// zero terminated string.
|
||||||
|
const cmChar_t* cmHashTblStr( cmHashTblH_t h, unsigned id );
|
||||||
|
|
||||||
|
// Remove a value.
|
||||||
|
cmHtRC_t cmHashTblRemove( cmHashTblH_t h, unsigned id );
|
||||||
|
|
||||||
|
// Return the last error id generated by the cmHashTbl object.
|
||||||
|
cmHtRC_t cmHashTblLastRC( cmHashTblH_t h );
|
||||||
|
|
||||||
|
void cmHashTblReport( cmHashTblH_t h, cmRpt_t* rpt );
|
||||||
|
|
||||||
|
cmHtRC_t cmHashTblTest( cmCtx_t* ctx );
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif
|
||||||
Loading…
Reference in New Issue
Block a user