UINT32 carray_search_back(const CARRAY *carray, const void *data, EC_BOOL (*cmp)(const void *, const void *))
{
UINT32 pos;
CARRAY_DATA_CMP data_cmp;
if(NULL_PTR == cmp)
{
data_cmp = carray_data_cmp_default;
}
else
{
data_cmp = cmp;
}
CARRAY_LOCK(carray, LOC_CARRAY_0024);
for(pos = carray->size; pos -- > 0; )
{
if(EC_TRUE == data_cmp(carray->data[ pos ], data))
{
CARRAY_UNLOCK(carray, LOC_CARRAY_0025);
return pos;
}
}
CARRAY_UNLOCK(carray, LOC_CARRAY_0026);
return CARRAY_ERR_POS;
}
EC_BOOL cbc_md_reg(const UINT32 md_type, const UINT32 md_capaciy)
{
CINDEX *md_cindex;
CARRAY_LOCK(g_cbc, LOC_CBC_0004);
if(md_type >= carray_size(g_cbc))
{
sys_log(LOGSTDOUT, "error:cbc_md_reg: md_type %ld overflow the cbc size %ld", md_type, carray_size(g_cbc));
CARRAY_UNLOCK(g_cbc, LOC_CBC_0005);
return (EC_FALSE);
}
md_cindex = (CINDEX *)carray_get_no_lock(g_cbc, md_type);
if(NULL_PTR != md_cindex)
{
sys_log(LOGSTDOUT, "error:cbc_md_reg: md_type %ld has already registered\n", md_type);
CARRAY_UNLOCK(g_cbc, LOC_CBC_0006);
return (EC_FALSE);
}
md_cindex = cindex_new(md_capaciy, MM_UINT32, LOC_CBC_0007);/*note: the data item type is (void *) */
if(NULL_PTR == md_cindex)
{
sys_log(LOGSTDOUT, "error:cbc_md_reg: failed to register md_type %ld\n", md_type);
CARRAY_UNLOCK(g_cbc, LOC_CBC_0008);
return (EC_FALSE);
}
carray_set_no_lock(g_cbc, md_type, md_cindex);
CARRAY_UNLOCK(g_cbc, LOC_CBC_0009);
sys_log(LOGSTDOUT, "[DEBUG] cbc_md_reg: reg type %ld, capacity %ld\n", md_type, md_capaciy);
return (EC_TRUE);
}
EC_BOOL cbc_print(LOG *log)
{
UINT32 md_type;
CINDEX *md_cindex;
CARRAY_LOCK(g_cbc, LOC_CBC_0019);
sys_log(log, "---------------------------------- cbc_print beg ------------------------\n");
if(NULL_PTR == g_cbc)
{
sys_log(log, "cbc_print: error:g_cbc is null\n");
CARRAY_UNLOCK(g_cbc, LOC_CBC_0020);
return (EC_FALSE);
}
sys_log(log, "cbc_print: cbc size: %ld\n", cbc_size());
for(md_type = 0; md_type < cbc_size(); md_type ++)
{
md_cindex = (CINDEX *)carray_get_no_lock(g_cbc, md_type);
if(NULL_PTR == md_cindex)
{
continue;
}
sys_log(log, "cbc_print: md_type: %ld, md_cindex: %lx\n", md_type, md_cindex);
cindex_print(log, md_cindex, 0);
}
sys_log(log, "---------------------------------- cbc_print end ------------------------\n");
CARRAY_UNLOCK(g_cbc, LOC_CBC_0021);
return (EC_TRUE);
}
void *carray_get(const CARRAY *carray, const UINT32 pos)
{
void *data;
CARRAY_LOCK(carray, LOC_CARRAY_0008);
if(pos >= carray->size)
{
CARRAY_UNLOCK(carray, LOC_CARRAY_0009);
return (void *)0;
}
data = carray->data[ pos ];
CARRAY_UNLOCK(carray, LOC_CARRAY_0010);
return (data);
}
/*return old data*/
void *carray_set(CARRAY *carray, const UINT32 pos, const void *data)
{
void *old_data;
CARRAY_LOCK(carray, LOC_CARRAY_0011);
if(pos >= carray->size)
{
CARRAY_UNLOCK(carray, LOC_CARRAY_0012);
return (void *)0;
}
old_data = carray->data[ pos ];
carray->data[ pos ] = (void *)data;
CARRAY_UNLOCK(carray, LOC_CARRAY_0013);
return old_data;
}
UINT32 cbc_sum()
{
UINT32 md_type;
CINDEX *md_cindex;
UINT32 md_sum;
if(NULL_PTR == g_cbc)
{
sys_log(LOGSTDOUT, "cbc_sum: error:g_cbc is null\n");
return (0);
}
CARRAY_LOCK(g_cbc, LOC_CBC_0017);
md_sum = 0;
for(md_type = 0; md_type < cbc_size(); md_type ++)
{
md_cindex = (CINDEX *)carray_get_no_lock(g_cbc, md_type);
if(NULL_PTR == md_cindex)
{
continue;
}
md_sum += cindex_size(md_cindex);
}
CARRAY_UNLOCK(g_cbc, LOC_CBC_0018);
return (md_sum);
}
void *carray_erase(CARRAY *carray, const UINT32 pos)
{
void *old_data;
CARRAY_LOCK(carray, LOC_CARRAY_0014);
if(pos >= carray->size)
{
CARRAY_UNLOCK(carray, LOC_CARRAY_0015);
return (void *)0;
}
old_data = carray->data[ pos ];
carray->data[ pos ] = (void *)0;
CARRAY_UNLOCK(carray, LOC_CARRAY_0016);
return old_data;
}
void carray_loop_front(const CARRAY *carray, EC_BOOL (*handler)(void *))
{
UINT32 pos;
CARRAY_LOCK(carray, LOC_CARRAY_0017);
for(pos = 0; pos < carray->size; pos ++)
{
handler(carray->data[ pos ]);
}
CARRAY_UNLOCK(carray, LOC_CARRAY_0018);
return;
}
void carray_free(CARRAY *carray, const UINT32 location)
{
CARRAY_LOCK(carray, LOC_CARRAY_0001);
if(carray->data)
{
SAFE_FREE(carray->data, location);
carray->data = (void **)0;
carray->size = 0;
}
CARRAY_UNLOCK(carray, LOC_CARRAY_0002);
CARRAY_CLEAN_LOCK(carray, LOC_CARRAY_0003);
SAFE_FREE(carray, location);
}
void carray_clean(CARRAY *carray, EC_BOOL (*cleaner)(void *))
{
CARRAY_LOCK(carray, LOC_CARRAY_0027);
carray_loop_front(carray, 0 == cleaner? carray_null_default : cleaner);
SAFE_FREE(carray->data, LOC_CARRAY_0028);
carray->data = (void **)0;
carray->size = 0;
CARRAY_UNLOCK(carray, LOC_CARRAY_0029);
return;
}
void carray_loop_back(const CARRAY *carray, EC_BOOL (*handler)(void *))
{
UINT32 pos;
CARRAY_LOCK(carray, LOC_CARRAY_0019);
for(pos = carray->size; pos -- > 0; )
{
handler(carray->data[ pos ]);
}
CARRAY_UNLOCK(carray, LOC_CARRAY_0020);
return;
}
EC_BOOL cbc_md_unreg(const UINT32 md_type)
{
CINDEX *md_cindex;
CARRAY_LOCK(g_cbc, LOC_CBC_0010);
md_cindex = (CINDEX *)carray_erase(g_cbc, md_type);
if(NULL_PTR != md_cindex)
{
cindex_clean(md_cindex, cbc_data_cleaner, LOC_CBC_0011);
cindex_free(md_cindex, LOC_CBC_0012);
}
CARRAY_UNLOCK(g_cbc, LOC_CBC_0013);
sys_log(LOGSTDOUT, "[DEBUG] cbc_md_unreg: unreg type %ld\n", md_type);
return (EC_TRUE);
}
void carray_print(LOG *log, const CARRAY *carray, void (*print)(LOG *, const void *))
{
UINT32 pos;
CARRAY_LOCK(carray, LOC_CARRAY_0030);
for(pos = 0; pos < carray->size; pos ++)
{
sys_log(log, "No. %ld: ", pos);
if(NULL_PTR == print)
{
sys_log(log, "%lx\n", carray->data[ pos ]);
}
else
{
print(log, carray->data[ pos ]);
}
}
CARRAY_UNLOCK(carray, LOC_CARRAY_0031);
return;
}
