static void
__delete_c_rb_node (struct clib_rb* pTree, struct clib_rb_node* x ) {
void* key;
void* value;
if ( pTree->destruct_k_fn ) {
get_raw_clib_object ( x->key, &key );
pTree->destruct_k_fn ( key );
}
delete_clib_object( x->key );
if ( x->value ) {
if ( pTree->destruct_v_fn ) {
get_raw_clib_object ( x->value, &value);
pTree->destruct_v_fn ( value );
}
delete_clib_object( x->value );
}
}
void
for_each_c_slist (struct clib_slist* pSlist, void (*fn)(void* )) {
void* elem;
struct clib_slist_node* current = pSlist->head;
while ( current != (struct clib_slist_node*)0 ) {
get_raw_clib_object(current->elem, &elem);
(fn)(elem);
free ( elem );
current = current->next;
}
}
static void
__remove_c_list ( struct clib_slist* pSlist, struct clib_slist_node* pSlistNode ) {
void* elem;
get_raw_clib_object(pSlistNode->elem, &elem);
if ( pSlist->destruct_fn) {
(pSlist->destruct_fn)(elem);
delete_clib_object ( pSlistNode->elem );
}else {
free ( elem );
delete_clib_object ( pSlistNode->elem );
}
free ( pSlistNode);
}
static void
replace_value_c_slist(struct clib_iterator *pIterator, void* elem, size_t elem_size) {
struct clib_slist* pSlist = (struct clib_slist*)pIterator->pContainer;
struct clib_object *pObj = ((struct clib_slist_node*)pIterator->pCurrentElement)->elem;
if ( pSlist->destruct_fn ) {
void* old_element;
get_raw_clib_object (pObj, &old_element );
pSlist->destruct_fn(old_element);
}
replace_raw_clib_object( pObj, elem, elem_size);
}
clib_error
remove_clib_map ( struct clib_map *pMap, void *key) {
clib_error rc = CLIB_ERROR_SUCCESS;
struct clib_rb_node* node;
if (pMap == (struct clib_map*)0)
return CLIB_MAP_NOT_INITIALIZED;
node = remove_clib_rb ( pMap->root, key );
if ( node != (struct clib_rb_node*)0 ) {
void* removed_node;
get_raw_clib_object ( node->key, &removed_node );
free ( removed_node);
delete_clib_object ( node->key );
get_raw_clib_object ( node->value, &removed_node );
free ( removed_node);
delete_clib_object ( node->value);
free ( node );
}
return rc;
}
clib_error
element_at_clib_array (struct clib_array* pArray, int index, void** elem) {
clib_error rc = CLIB_ERROR_SUCCESS;
if ( ! pArray )
return CLIB_ARRAY_NOT_INITIALIZED;
if ( index < 0 || index >= pArray->no_of_elements )
return CLIB_ARRAY_INDEX_OUT_OF_BOUND;
get_raw_clib_object ( pArray->pElements[index], elem );
return rc;
}
clib_bool
find_c_slist (struct clib_slist* pSlist, void* find_value, void**out_value) {
struct clib_slist_node* current = pSlist->head;
while ( current != (struct clib_slist_node*)0 ) {
get_raw_clib_object(current->elem, out_value);
if ((pSlist->compare_key_fn)(find_value,*out_value) != 0){
break;
}
free ( *out_value );
current = current->next;
}
if ( current ) {
return clib_true;
}
return clib_false;
}
clib_bool
find_clib_map ( struct clib_map *pMap, void *key, void **value) {
struct clib_rb_node* node;
if (pMap == (struct clib_map*)0)
return clib_false;
node = find_clib_rb ( pMap->root, key);
if ( node == (struct clib_rb_node*)0 )
return clib_false;
get_raw_clib_object ( node->value, value );
return clib_true;
}
clib_bool
find_clib_set ( struct clib_set *pSet, void *key, void* outKey) {
struct clib_rb_node* node;
if (pSet == (struct clib_set*)0 )
return clib_false;
node = find_clib_rb ( pSet->root, key);
if ( node == (struct clib_rb_node*)0 )
return clib_false;
get_raw_clib_object ( node->key, outKey );
return clib_true;
}
struct clib_rb_node*
find_c_rb (struct clib_rb* pTree, void* key) {
struct clib_rb_node* x = pTree->root;
while (x != rb_sentinel) {
int c = 0;
void* cur_key ;
get_raw_clib_object ( x->key, &cur_key );
c = pTree->compare_fn (key, cur_key);
free ( cur_key );
if (c == 0) {
break;
} else {
x = c < 0 ? x->left : x->right;
}
}
if ( x == rb_sentinel )
return (struct clib_rb_node*)0 ;
return x;
}
struct clib_rb_node*
remove_c_rb (struct clib_rb* pTree, void* key) {
struct clib_rb_node* z = (struct clib_rb_node*)0 ;
z = pTree->root;
while (z != rb_sentinel) {
int c = 0;
void* cur_key;
get_raw_clib_object ( z->key, &cur_key );
c = pTree->compare_fn (key, cur_key);
free ( cur_key );
if ( c == 0) {
break;
}
else {
z = ( c < 0) ? z->left : z->right;
}
}
if (z == rb_sentinel)
return (struct clib_rb_node*)0 ;
return __remove_c_rb(pTree, z );
}
static void*
get_value_c_slist( void* pObject) {
void* elem;
get_raw_clib_object ( pObject, &elem );
return elem;
}
clib_error
insert_c_rb(struct clib_rb* pTree, void* k, size_t key_size, void* v, size_t value_size) {
clib_error rc = CLIB_ERROR_SUCCESS;
struct clib_rb_node* x;
struct clib_rb_node* y;
struct clib_rb_node* z;
x = (struct clib_rb_node*)malloc (sizeof(struct clib_rb_node));
if ( x == (struct clib_rb_node*)0 )
return CLIB_ERROR_MEMORY;
x->left = rb_sentinel;
x->right = rb_sentinel;
x->color = clib_red;
x->key = new_clib_object ( k, key_size );
if ( v ) {
x->value = new_clib_object ( v, value_size );
} else {
x->value = (struct clib_object*)0;
}
y = pTree->root;
z = (struct clib_rb_node*)0 ;
while (y != rb_sentinel) {
int c = 0;
void* cur_key;
void* new_key;
get_raw_clib_object ( y->key, &cur_key );
get_raw_clib_object ( x->key, &new_key );
c = (pTree->compare_fn) ( new_key , cur_key);
free ( cur_key );
free ( new_key );
if (c == 0) {
/* TODO : Delete node here */
return CLIB_RBTREE_KEY_DUPLICATE;
}
z = y;
if ( c < 0 )
y = y->left;
else
y = y->right;
}
x->parent = z;
if (z) {
int c = 0;
void* cur_key;
void* new_key;
get_raw_clib_object ( z->key, &cur_key );
get_raw_clib_object ( x->key, &new_key );
c = pTree->compare_fn( new_key, cur_key);
free ( cur_key );
free ( new_key );
if (c < 0) {
z->left = x;
} else {
z->right = x;
}
}
else
pTree->root = x;
__rb_insert_fixup (pTree, x);
debug_verify_properties ( pTree);
return rc;
}
