static void layer_index_free(layer_index_t *layer_index)
{
layer_index_t *cur_layer_index=layer_index;
layer_index_t *next_layer_index=NULL;
elem_t *cur_elem=NULL;
elem_t *next_elem=NULL;
if(NULL==cur_layer_index){
return;
}
while(NULL!=cur_layer_index){
next_layer_index=cur_layer_index->next_layer;
cur_elem=cur_layer_index->elem;
while(NULL!=cur_elem){
next_elem=cur_elem->next_elem;
elem_free(cur_elem,int_elem_free);
cur_elem=next_elem;
}
free_layer_index(cur_layer_index);
cur_layer_index=next_layer_index;
}
return;
}
void hm_delete_elems(hm_t* hm, void (*elem_free)(void *)) {
int i,j;
for(i = 0; i < hm->_elems; ++i) {
if(hm->_bucket_lengths[i] == 0) continue;
for(j = 0; j < hm->_bucket_lengths[i]; ++j) {
elem_free(hm->_buckets[i][j]);
}
}
}
/*ARGSUSED*/
static void set_prod_iter_exit(SetIter* iter, const Set* set)
{
int i;
assert(set_prod_iter_is_valid(iter));
assert(set_prod_is_valid(set));
SID_del2(iter->prod);
set_iter_exit_intern(iter->prod.iter_a, set->prod.set_a);
set_iter_exit_intern(iter->prod.iter_b, set->prod.set_b);
for(i = 0; i < set->head.dim; i++)
if (iter->prod.elem[i] != NULL)
elem_free(iter->prod.elem[i]);
free(iter->prod.elem);
free(iter);
}
void list_free(List* list)
{
ListElem* p;
ListElem* q;
assert(list_is_valid(list));
list->refc--;
if (list->refc == 0)
{
SID_del(list);
for(p = list->anchor.next; p != &list->anchor; p = q)
{
q = p->next;
switch(list->type)
{
case LIST_ELEM :
elem_free(p->data.elem);
break;
case LIST_TUPLE :
tuple_free(p->data.tuple);
break;
case LIST_ENTRY :
entry_free(p->data.entry);
break;
case LIST_IDXELEM :
break;
case LIST_LIST :
list_free(p->data.list);
break;
default :
abort();
}
blk_free(p, sizeof(*p));
}
free(list);
}
}
/*ARGSUSED*/
static Bool set_prod_iter_next(
SetIter* iter,
const Set* set,
Tuple* tuple,
int offset)
{
Set* a;
Set* b;
SetIter* iter_a;
SetIter* iter_b;
int offset2;
int i;
assert(set_prod_iter_is_valid(iter));
assert(set_prod_is_valid(set));
assert(tuple_is_valid(tuple));
assert(offset >= 0);
assert(offset + set->head.dim <= tuple_get_dim(tuple));
a = set->prod.set_a;
b = set->prod.set_b;
iter_a = iter->prod.iter_a;
iter_b = iter->prod.iter_b;
offset2 = offset + a->head.dim;
if (iter->prod.first)
{
iter->prod.first = FALSE;
return get_both_parts(a, b, iter, iter_a, iter_b, tuple, offset, offset2);
}
assert(!iter->prod.first);
/* Get back part
*/
if (set_iter_next_intern(iter_b, b, tuple, offset2))
{
/* copy fore part
*/
for(i = 0; i < a->head.dim; i++)
tuple_set_elem(tuple, i + offset, elem_copy(iter->prod.elem[i]));
return TRUE;
}
/* No back part, so reset it
*/
set_iter_reset_intern(iter_b, b);
/* Clear elem cache
*/
for(i = 0; i < set->head.dim; i++)
{
if (iter->prod.elem[i] != NULL)
{
elem_free(iter->prod.elem[i]);
iter->prod.elem[i] = NULL;
}
}
return get_both_parts(a, b, iter, iter_a, iter_b, tuple, offset, offset2);
}
static void pvector_free_elem(void *e, void *user) {
void *p = *((void **)e);
RPVectorFree elem_free = (RPVectorFree)user;
elem_free (p);
}
main( int argc, char **argv )
{
fbuf_uint32_t buf_sz = 512;
int N_frames = 2;
const char filename[] = "fbuf.data";
filebuf_t *fbuf_ptr;
MixedElem *elem_ptr;
int icontinue;
fbuf_uint32_t frame_count;
fbuf_uint32_t frame_idx_max;
fbuf_uint32_t frame_idx;
fbuf_uint32_t N_frame_elem;
fbuf_uint32_t elem_idx;
if ( argc > 1 )
if ( isdigit( argv[1][0] ) ) buf_sz = atoi( argv[1] );
if ( argc > 2 )
if ( isdigit( argv[2][0] ) ) N_frames = atoi( argv[2] );
fbuf_ptr = fbuf_create( buf_sz );
fbuf_filedesc( fbuf_ptr, fopen( filename, "wb" ) );
bswp_fwrite( &(fbuf_ptr->bsize),
sizeof( fbuf_uint32_t ), 1, fbuf_ptr->fd );
elem_idx = 0;
for ( frame_count = 0; frame_count < N_frames; frame_count++ ) {
fbuf_increment( sizeof( fbuf_uint32_t ), fbuf_ptr );
icontinue = true; frame_idx = 0;
while( icontinue ) {
elem_ptr = elem_create( ( double ) ( elem_idx * 10 ),
( int ) elem_idx );
if ( icontinue = elem2fbuf( fbuf_ptr, elem_ptr ) ) {
printf( "elem_idx = %d, used buffer = %d\n",
elem_idx,
fbuf_ptr->ptr - fbuf_ptr->head );
frame_idx++; elem_idx++;
}
else {
frame_idx_max = frame_idx - 1;
N_frame_elem = frame_idx;
}
elem_free( elem_ptr );
}
/* set fbuf to its head */
fbuf_decrement( fbuf_ptr->ptr - fbuf_ptr->head, fbuf_ptr );
fbuf_deposit( &N_frame_elem, sizeof( fbuf_uint32_t ), 1,
fbuf_ptr );
/*
memcpy( fbuf_ptr->head, &N_frame_elem,
sizeof( fbuf_uint32_t )/sizeof( char ) );
*/
fbuf_empty( fbuf_ptr );
}
printf( "sizeof( MixedElem ) = %d\n",
sizeof( MixedElem )/sizeof( char ) );
printf( "The elem_idx_max is %d\n", elem_idx-1 );
fclose( fbuf_ptr->fd );
fbuf_free( fbuf_ptr );
}
