/**
* 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;
}
multimap_iterator_t multimap_insert_hint(
multimap_t* pt_multimap, multimap_iterator_t t_hint, const pair_t* cpt_pair)
{
pair_t t_elempair;
assert(pt_multimap != NULL && cpt_pair != NULL);
assert(_same_multimap_pair_type(&pt_multimap->_t_pair, cpt_pair));
/* initialize the new pair */
t_elempair = _create_pair(
pt_multimap->_t_pair._t_firsttypesize, pt_multimap->_t_pair._sz_firsttypename,
pt_multimap->_t_pair._t_secondtypesize, pt_multimap->_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_MULTIMAP_AVL_TREE
t_hint = _avl_tree_insert_equal(_GET_MULTIMAP_AVL_TREE(pt_multimap), &t_elempair);
#else
t_hint = _rb_tree_insert_equal(_GET_MULTIMAP_RB_TREE(pt_multimap), &t_elempair);
#endif
/*
* There is no need for destroy the elempair, because the pair is copied
* to the tree, and it is destroied by tree when tree is desroied.
*/
_GET_CONTAINER(&t_hint) = pt_multimap;
_GET_MULTIMAP_CONTAINER_TYPE(&t_hint) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(&t_hint) = _BIDIRECTIONAL_ITERATOR;
return t_hint;
}
multimap_iterator_t _multimap_upper_bound_varg(
const multimap_t* cpt_multimap, va_list val_elemlist)
{
multimap_iterator_t t_iterator;
assert(cpt_multimap != NULL);
_get_varg_value(
cpt_multimap->_t_pair.first,
val_elemlist,
cpt_multimap->_t_pair._t_firsttypesize,
cpt_multimap->_t_pair._sz_firsttypename);
#ifdef CSTL_MULTIMAP_AVL_TREE
t_iterator = _avl_tree_upper_bound(
_GET_MULTIMAP_AVL_TREE(cpt_multimap), &cpt_multimap->_t_pair);
#else
t_iterator = _rb_tree_upper_bound(
_GET_MULTIMAP_RB_TREE(cpt_multimap), &cpt_multimap->_t_pair);
#endif
_GET_CONTAINER(&t_iterator) = (multimap_t*)cpt_multimap;
_GET_MULTIMAP_CONTAINER_TYPE(&t_iterator) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(&t_iterator) = _BIDIRECTIONAL_ITERATOR;
return t_iterator;
}
pair_t _multimap_equal_range_varg(
const multimap_t* cpt_multimap, va_list val_elemlist)
{
multimap_iterator_t t_first;
multimap_iterator_t t_second;
pair_t t_pair;
#ifdef CSTL_MULTIMAP_AVL_TREE
avl_tree_result_pair_t t_avlresult;
#else
rb_tree_result_pair_t t_rbresult;
#endif
assert(cpt_multimap != NULL);
_get_varg_value(
cpt_multimap->_t_pair.first,
val_elemlist,
cpt_multimap->_t_pair._t_firsttypesize,
cpt_multimap->_t_pair._sz_firsttypename);
#ifdef CSTL_MULTIMAP_AVL_TREE
t_avlresult = _avl_tree_equal_range(
_GET_MULTIMAP_AVL_TREE(cpt_multimap), &cpt_multimap->_t_pair);
t_first = t_avlresult._t_first;
t_second = t_avlresult._t_second._t_iterator;
#else
t_rbresult = _rb_tree_equal_range(
_GET_MULTIMAP_RB_TREE(cpt_multimap), &cpt_multimap->_t_pair);
t_first = t_rbresult._t_first;
t_second = t_rbresult._t_second._t_iterator;
#endif
_GET_CONTAINER(&t_first) = (multimap_t*)cpt_multimap;
_GET_MULTIMAP_CONTAINER_TYPE(&t_first) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(&t_first) = _BIDIRECTIONAL_ITERATOR;
_GET_CONTAINER(&t_second) = (multimap_t*)cpt_multimap;
_GET_MULTIMAP_CONTAINER_TYPE(&t_second) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(&t_second) = _BIDIRECTIONAL_ITERATOR;
t_pair = create_pair(multimap_iterator_t, multimap_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;
}
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;
}
/**
* Return an iterator range that is equal to a specific element.
*/
range_t _multimap_equal_range_varg(const multimap_t* cpmmap_map, va_list val_elemlist)
{
range_t r_range;
assert(cpmmap_map != NULL);
assert(_pair_is_inited(&cpmmap_map->_pair_temp));
_type_get_varg_value(&((multimap_t*)cpmmap_map)->_pair_temp._t_typeinfofirst, val_elemlist, cpmmap_map->_pair_temp._pv_first);
#ifdef CSTL_MULTIMAP_AVL_TREE
r_range = _avl_tree_equal_range(&cpmmap_map->_t_tree, &cpmmap_map->_pair_temp);
#else
r_range = _rb_tree_equal_range(&cpmmap_map->_t_tree, &cpmmap_map->_pair_temp);
#endif
_GET_CONTAINER(r_range.it_begin) = (multimap_t*)cpmmap_map;
_GET_MULTIMAP_CONTAINER_TYPE(r_range.it_begin) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(r_range.it_begin) = _BIDIRECTIONAL_ITERATOR;
_GET_CONTAINER(r_range.it_end) = (multimap_t*)cpmmap_map;
_GET_MULTIMAP_CONTAINER_TYPE(r_range.it_end) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(r_range.it_end) = _BIDIRECTIONAL_ITERATOR;
return r_range;
}
/**
* Return an iterator that addresses the location succeeding the last element in the hash_multimap.
*/
hash_multimap_iterator_t hash_multimap_end(const hash_multimap_t* cphmmap_map)
{
hash_multimap_iterator_t it_end;
assert(cphmmap_map != NULL);
assert(_pair_is_inited(&cphmmap_map->_pair_temp));
it_end = _hashtable_end(&cphmmap_map->_t_hashtable);
_GET_CONTAINER(it_end) = (hash_multimap_t*)cphmmap_map;
_GET_HASH_MULTIMAP_CONTAINER_TYPE(it_end) = _HASH_MULTIMAP_CONTAINER;
_GET_HASH_MULTIMAP_ITERATOR_TYPE(it_end) = _BIDIRECTIONAL_ITERATOR;
return it_end;
}
multimap_reverse_iterator_t multimap_rend(const multimap_t* cpt_multimap)
{
multimap_reverse_iterator_t t_newiterator;
assert(cpt_multimap != NULL);
#ifdef CSTL_MULTIMAP_AVL_TREE
t_newiterator = _avl_tree_rend(_GET_MULTIMAP_AVL_TREE(cpt_multimap));
#else
t_newiterator = _rb_tree_rend(_GET_MULTIMAP_RB_TREE(cpt_multimap));
#endif
_GET_CONTAINER(&t_newiterator) = (multimap_t*)cpt_multimap;
_GET_MULTIMAP_CONTAINER_TYPE(&t_newiterator) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(&t_newiterator) = _BIDIRECTIONAL_ITERATOR;
return t_newiterator;
}
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;
}
/**
* Return an iterator to the first element that is greater than a specific element.
*/
multimap_iterator_t _multimap_upper_bound_varg(const multimap_t* cpmmap_map, va_list val_elemlist)
{
multimap_iterator_t it_iter;
assert(cpmmap_map != NULL);
assert(_pair_is_inited(&cpmmap_map->_pair_temp));
_type_get_varg_value(&((multimap_t*)cpmmap_map)->_pair_temp._t_typeinfofirst, val_elemlist, cpmmap_map->_pair_temp._pv_first);
#ifdef CSTL_MULTIMAP_AVL_TREE
it_iter = _avl_tree_upper_bound(&cpmmap_map->_t_tree, &cpmmap_map->_pair_temp);
#else
it_iter = _rb_tree_upper_bound(&cpmmap_map->_t_tree, &cpmmap_map->_pair_temp);
#endif
_GET_CONTAINER(it_iter) = (multimap_t*)cpmmap_map;
_GET_MULTIMAP_CONTAINER_TYPE(it_iter) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(it_iter) = _BIDIRECTIONAL_ITERATOR;
return it_iter;
}
/**
* Inserts an unique element into a hash_multimap.
*/
hash_multimap_iterator_t hash_multimap_insert(hash_multimap_t* phmmap_map, const pair_t* cppair_pair)
{
hash_multimap_iterator_t it_iter;
assert(phmmap_map != NULL);
assert(cppair_pair != NULL);
assert(_pair_is_inited(&phmmap_map->_pair_temp));
assert(_pair_is_inited(cppair_pair));
((pair_t*)cppair_pair)->_bfun_mapkeycompare = phmmap_map->_bfun_keycompare;
((pair_t*)cppair_pair)->_bfun_mapvaluecompare = phmmap_map->_bfun_valuecompare;
assert(_hash_multimap_same_pair_type_ex(&phmmap_map->_pair_temp, cppair_pair));
/* insert int hashtable */
it_iter = _hashtable_insert_equal(&phmmap_map->_t_hashtable, cppair_pair);
_GET_CONTAINER(it_iter) = phmmap_map;
_GET_HASH_MULTIMAP_CONTAINER_TYPE(it_iter) = _HASH_MULTIMAP_CONTAINER;
_GET_HASH_MULTIMAP_ITERATOR_TYPE(it_iter) = _BIDIRECTIONAL_ITERATOR;
return it_iter;
}
