/**
* Inserts an unique element into a map with hint position.
*/
map_iterator_t map_insert_hint(map_t* pmap_map, map_iterator_t it_hint, const pair_t* cppair_pair)
{
assert(pmap_map != NULL);
assert(cppair_pair != NULL);
assert(_pair_is_inited(&pmap_map->_pair_temp));
assert(_pair_is_inited(cppair_pair));
assert(_GET_MAP_CONTAINER_TYPE(it_hint) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_hint) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER(it_hint) == pmap_map);
/* set key less function and value less function */
((pair_t*)cppair_pair)->_bfun_mapkeycompare = pmap_map->_bfun_keycompare;
((pair_t*)cppair_pair)->_bfun_mapvaluecompare = pmap_map->_bfun_valuecompare;
assert(_map_same_pair_type_ex(&pmap_map->_pair_temp, cppair_pair));
#ifdef CSTL_MAP_AVL_TREE
it_hint = _avl_tree_insert_unique(&pmap_map->_t_tree, cppair_pair);
#else
it_hint = _rb_tree_insert_unique(&pmap_map->_t_tree, cppair_pair);
#endif
_GET_CONTAINER(it_hint) = pmap_map;
_GET_MAP_CONTAINER_TYPE(it_hint) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(it_hint) = _BIDIRECTIONAL_ITERATOR;
return it_hint;
}
/*
* Erase a range of element in an map.
*/
void map_erase_range(map_t* pmap_map, map_iterator_t it_begin, map_iterator_t it_end)
{
assert(pmap_map != NULL);
assert(_pair_is_inited(&pmap_map->_pair_temp));
assert(_GET_MAP_CONTAINER_TYPE(it_begin) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_begin) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER_TYPE(it_end) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_end) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER(it_begin) == pmap_map && _GET_MAP_CONTAINER(it_end) == pmap_map);
#ifdef CSTL_MAP_AVL_TREE
_avl_tree_erase_range(&pmap_map->_t_tree, it_begin, it_end);
#else
_rb_tree_erase_range(&pmap_map->_t_tree, it_begin, it_end);
#endif
}
map_iterator_t _map_upper_bound_varg(const map_t* cpt_map, va_list val_elemlist)
{
map_iterator_t t_iterator;
assert(cpt_map != NULL);
_get_varg_value(
cpt_map->_t_pair.first,
val_elemlist,
cpt_map->_t_pair._t_firsttypesize,
cpt_map->_t_pair._sz_firsttypename);
#ifdef CSTL_MAP_AVL_TREE
t_iterator =
_avl_tree_upper_bound(_GET_MAP_AVL_TREE(cpt_map), &cpt_map->_t_pair);
#else
t_iterator =
_rb_tree_upper_bound(_GET_MAP_RB_TREE(cpt_map), &cpt_map->_t_pair);
#endif
_GET_CONTAINER(&t_iterator) = (map_t*)cpt_map;
_GET_MAP_CONTAINER_TYPE(&t_iterator) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(&t_iterator) = _BIDIRECTIONAL_ITERATOR;
return t_iterator;
}
bool_t _map_iterator_before(
const map_iterator_t* cpt_iteratorfirst, const map_iterator_t* cpt_iteratorsecond)
{
assert(cpt_iteratorfirst != NULL && cpt_iteratorsecond != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(cpt_iteratorfirst) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(cpt_iteratorfirst) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(cpt_iteratorsecond) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(cpt_iteratorsecond) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER(cpt_iteratorfirst) == _GET_MAP_CONTAINER(cpt_iteratorsecond));
#ifdef CSTL_MAP_AVL_TREE
return _avl_tree_iterator_before(cpt_iteratorfirst, cpt_iteratorsecond);
#else
return _rb_tree_iterator_before(cpt_iteratorfirst, cpt_iteratorsecond);
#endif
}
int _map_iterator_distance(
const map_iterator_t* cpt_begin, const map_iterator_t* cpt_end)
{
assert(cpt_begin != NULL && cpt_end != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(cpt_begin) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(cpt_begin) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(cpt_end) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(cpt_end) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER(cpt_begin) == _GET_MAP_CONTAINER(cpt_end));
#ifdef CSTL_MAP_AVL_TREE
return _avl_tree_iterator_distance(cpt_begin, cpt_end);
#else
return _rb_tree_iterator_distance(cpt_begin, cpt_end);
#endif
}
pair_t _map_equal_range_varg(const map_t* cpt_map, va_list val_elemlist)
{
map_iterator_t t_first;
map_iterator_t t_second;
pair_t t_pair;
#ifdef CSTL_MAP_AVL_TREE
avl_tree_result_pair_t t_avlresult;
#else
rb_tree_result_pair_t t_rbresult;
#endif
assert(cpt_map != NULL);
_get_varg_value(
cpt_map->_t_pair.first,
val_elemlist,
cpt_map->_t_pair._t_firsttypesize,
cpt_map->_t_pair._sz_firsttypename);
#ifdef CSTL_MAP_AVL_TREE
t_avlresult =
_avl_tree_equal_range(_GET_MAP_AVL_TREE(cpt_map), &cpt_map->_t_pair);
t_first = t_avlresult._t_first;
t_second = t_avlresult._t_second._t_iterator;
#else
t_rbresult =
_rb_tree_equal_range(_GET_MAP_RB_TREE(cpt_map), &cpt_map->_t_pair);
t_first = t_rbresult._t_first;
t_second = t_rbresult._t_second._t_iterator;
#endif
_GET_CONTAINER(&t_first) = (map_t*)cpt_map;
_GET_MAP_CONTAINER_TYPE(&t_first) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(&t_first) = _BIDIRECTIONAL_ITERATOR;
_GET_CONTAINER(&t_second) = (map_t*)cpt_map;
_GET_MAP_CONTAINER_TYPE(&t_second) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(&t_second) = _BIDIRECTIONAL_ITERATOR;
t_pair = create_pair(map_iterator_t, map_iterator_t);
pair_init(&t_pair);
memcpy(t_pair.first, &t_first, t_pair._t_firsttypesize);
memcpy(t_pair.second, &t_second, t_pair._t_secondtypesize);
return t_pair;
}
void map_erase_range(
map_t* pt_map, map_iterator_t t_begin, map_iterator_t t_end)
{
assert(pt_map != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(&t_begin) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_begin) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(&t_end) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_end) == _BIDIRECTIONAL_ITERATOR);
assert(
_GET_MAP_CONTAINER(&t_begin) == pt_map &&
_GET_MAP_CONTAINER(&t_end) == pt_map);
#ifdef CSTL_MAP_AVL_TREE
_avl_tree_erase_range(_GET_MAP_AVL_TREE(pt_map), t_begin, t_end);
#else
_rb_tree_erase_range(_GET_MAP_RB_TREE(pt_map), t_begin, t_end);
#endif
}
/**
* Inserts an range of unique element into a map.
*/
void map_insert_range(map_t* pmap_map, map_iterator_t it_begin, map_iterator_t it_end)
{
map_iterator_t it_iter;
assert(pmap_map != NULL);
assert(_pair_is_inited(&pmap_map->_pair_temp));
assert(_GET_MAP_CONTAINER_TYPE(it_begin) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_begin) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER_TYPE(it_end) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_end) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER(it_begin) != pmap_map);
assert(_GET_MAP_CONTAINER(it_end) != pmap_map);
assert(_GET_MAP_CONTAINER(it_begin) == _GET_MAP_CONTAINER(it_end));
assert(_map_same_pair_type(&pmap_map->_pair_temp, &_GET_MAP_CONTAINER(it_begin)->_pair_temp));
for(it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter))
{
map_insert(pmap_map, (pair_t*)iterator_get_pointer(it_iter));
}
}
/**
* Initialize map container with specific range and compare function.
*/
void map_init_copy_range_ex(map_t* pmap_dest, map_iterator_t it_begin, map_iterator_t it_end, binary_function_t bfun_keycompare)
{
assert(pmap_dest != NULL);
assert(_pair_is_created(&pmap_dest->_pair_temp));
assert(_GET_MAP_CONTAINER_TYPE(it_begin) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_begin) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER_TYPE(it_end) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_end) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER(it_begin) != pmap_dest);
assert(_GET_MAP_CONTAINER(it_end) != pmap_dest);
assert(_GET_MAP_CONTAINER(it_begin) == _GET_MAP_CONTAINER(it_end));
assert(_map_same_pair_type(&pmap_dest->_pair_temp, &_GET_MAP_CONTAINER(it_begin)->_pair_temp));
/* initialize dest map with src map attribute */
map_init_ex(pmap_dest, bfun_keycompare);
/* insert all element from src to dest */
if(!map_empty(_GET_MAP_CONTAINER(it_begin)))
{
map_insert_range(pmap_dest, it_begin, it_end);
}
}
map_iterator_t map_insert(map_t* pt_map, const pair_t* cpt_pair)
{
pair_t t_elempair;
map_iterator_t t_result;
#ifdef CSTL_MAP_AVL_TREE
avl_tree_result_pair_t t_avlresult;
#else
rb_tree_result_pair_t t_rbresult;
#endif
assert(pt_map != NULL && cpt_pair != NULL);
assert(_same_map_pair_type(&pt_map->_t_pair, cpt_pair));
/* initialize the new pair */
t_elempair = _create_pair(
pt_map->_t_pair._t_firsttypesize, pt_map->_t_pair._sz_firsttypename,
pt_map->_t_pair._t_secondtypesize, pt_map->_t_pair._sz_secondtypename);
pair_init(&t_elempair);
memcpy(t_elempair.first, cpt_pair->first, t_elempair._t_firsttypesize);
memcpy(t_elempair.second, cpt_pair->second, t_elempair._t_secondtypesize);
/* insert pair into tree */
#ifdef CSTL_MAP_AVL_TREE
t_avlresult = _avl_tree_insert_unique(_GET_MAP_AVL_TREE(pt_map), &t_elempair);
if(t_avlresult._t_second._t_bool)
{
t_result = t_avlresult._t_first;
}
else
{
t_result = map_end(pt_map);
pair_destroy(&t_elempair);
}
#else
t_rbresult = _rb_tree_insert_unique(_GET_MAP_RB_TREE(pt_map), &t_elempair);
if(t_rbresult._t_second._t_bool)
{
t_result = t_rbresult._t_first;
}
else
{
t_result = map_end(pt_map);
pair_destroy(&t_elempair);
}
#endif
_GET_CONTAINER(&t_result) = pt_map;
_GET_MAP_CONTAINER_TYPE(&t_result) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(&t_result) = _BIDIRECTIONAL_ITERATOR;
return t_result;
}
void map_init_copy_range_cmp(
map_t* pt_mapdest, map_iterator_t t_begin, map_iterator_t t_end,
int (*pfun_key_cmp)(const void*, const void*))
{
assert(pt_mapdest != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(&t_begin) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_begin) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(&t_end) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_end) == _BIDIRECTIONAL_ITERATOR);
assert(
_GET_MAP_CONTAINER(&t_begin) != pt_mapdest &&
_GET_MAP_CONTAINER(&t_end) != pt_mapdest &&
_GET_MAP_CONTAINER(&t_begin) == _GET_MAP_CONTAINER(&t_end));
assert(
pt_mapdest->_t_pair._t_firsttypesize ==
_GET_MAP_CONTAINER(&t_begin)->_t_pair._t_firsttypesize &&
pt_mapdest->_t_pair._t_secondtypesize ==
_GET_MAP_CONTAINER(&t_begin)->_t_pair._t_secondtypesize);
assert(
strncmp(
pt_mapdest->_t_pair._sz_firsttypename,
_GET_MAP_CONTAINER(&t_begin)->_t_pair._sz_firsttypename,
_ELEM_TYPE_NAME_SIZE) == 0 &&
strncmp(
pt_mapdest->_t_pair._sz_secondtypename,
_GET_MAP_CONTAINER(&t_begin)->_t_pair._sz_secondtypename,
_ELEM_TYPE_NAME_SIZE) == 0);
/* initialize dest map with src map attribute */
map_init(pt_mapdest);
pt_mapdest->_t_pair._pfun_first_cmp = pfun_key_cmp;
/* insert all element from src to dest */
if(!map_empty(_GET_MAP_CONTAINER(&t_begin)))
{
map_insert_range(pt_mapdest, t_begin, t_end);
}
}
void map_insert_range(
map_t* pt_map, map_iterator_t t_begin, map_iterator_t t_end)
{
map_iterator_t t_iterator;
assert(pt_map != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(&t_begin) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_begin) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(&t_end) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_end) == _BIDIRECTIONAL_ITERATOR);
assert(
_GET_MAP_CONTAINER(&t_begin) != pt_map &&
_GET_MAP_CONTAINER(&t_end) != pt_map &&
_GET_MAP_CONTAINER(&t_begin) == _GET_MAP_CONTAINER(&t_end));
for(t_iterator = t_begin;
!iterator_equal(&t_iterator, t_end);
iterator_next(&t_iterator))
{
map_insert(pt_map, (pair_t*)iterator_get_pointer(&t_iterator));
}
}
bool_t _map_iterator_equal(
const struct _tagmap* cpt_map,
const map_iterator_t* cpt_iterator,
map_iterator_t t_iterator)
{
assert(cpt_map != NULL && cpt_iterator != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(cpt_iterator) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(cpt_iterator) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(&t_iterator) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_iterator) == _BIDIRECTIONAL_ITERATOR);
assert(
_GET_MAP_CONTAINER(cpt_iterator) == cpt_map &&
_GET_MAP_CONTAINER(&t_iterator) == cpt_map);
#ifdef CSTL_MAP_AVL_TREE
return _avl_tree_iterator_equal(
_GET_MAP_AVL_TREE(cpt_map), cpt_iterator, t_iterator);
#else
return _rb_tree_iterator_equal(
_GET_MAP_RB_TREE(cpt_map), cpt_iterator, t_iterator);
#endif
}
void _map_iterator_prev(
const struct _tagmap* cpt_map, map_iterator_t* pt_iterator)
{
assert(cpt_map != NULL && pt_iterator != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(pt_iterator) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(pt_iterator) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER(pt_iterator) == cpt_map);
#ifdef CSTL_MAP_AVL_TREE
_avl_tree_iterator_prev(_GET_MAP_AVL_TREE(cpt_map), pt_iterator);
#else
_rb_tree_iterator_prev(_GET_MAP_RB_TREE(cpt_map), pt_iterator);
#endif
}
/* map iterator function */
map_iterator_t create_map_iterator(void)
{
map_iterator_t t_newiterator;
#ifdef CSTL_MAP_AVL_TREE
t_newiterator = _create_avl_tree_iterator();
#else
t_newiterator = _create_rb_tree_iterator();
#endif
_GET_MAP_CONTAINER_TYPE(&t_newiterator) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(&t_newiterator) = _BIDIRECTIONAL_ITERATOR;
return t_newiterator;
}
map_reverse_iterator_t map_rend(const map_t* cpt_map)
{
map_reverse_iterator_t t_newiterator;
assert(cpt_map != NULL);
#ifdef CSTL_MAP_AVL_TREE
t_newiterator = _avl_tree_rend(_GET_MAP_AVL_TREE(cpt_map));
#else
t_newiterator = _rb_tree_rend(_GET_MAP_RB_TREE(cpt_map));
#endif
_GET_CONTAINER(&t_newiterator) = (map_t*)cpt_map;
_GET_MAP_CONTAINER_TYPE(&t_newiterator) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(&t_newiterator) = _BIDIRECTIONAL_ITERATOR;
return t_newiterator;
}
void _map_iterator_get_value(
const struct _tagmap* cpt_map,
const map_iterator_t* cpt_iterator,
void* pv_value)
{
assert(cpt_map != NULL && cpt_iterator != NULL && pv_value != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(cpt_iterator) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(cpt_iterator) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER(cpt_iterator) == cpt_map);
#ifdef CSTL_MAP_AVL_TREE
_avl_tree_iterator_get_value(
_GET_MAP_AVL_TREE(cpt_map), cpt_iterator, pv_value);
#else
_rb_tree_iterator_get_value(
_GET_MAP_RB_TREE(cpt_map), cpt_iterator, pv_value);
#endif
}
map_reverse_iterator_t map_rend(const map_t* cpmap_map)
{
map_reverse_iterator_t it_rend;
assert(cpmap_map != NULL);
assert(_pair_is_inited(&cpmap_map->_pair_temp));
#ifdef CSTL_MAP_AVL_TREE
it_rend = _avl_tree_rend(&cpmap_map->_t_tree);
#else
it_rend = _rb_tree_rend(&cpmap_map->_t_tree);
#endif
_GET_CONTAINER(it_rend) = (map_t*)cpmap_map;
_GET_MAP_CONTAINER_TYPE(it_rend) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(it_rend) = _BIDIRECTIONAL_ITERATOR;
return it_rend;
}
