/**
* Test whether two iterator are equal types.
*/
bool_t _iterator_same_type(iterator_t it_first, iterator_t it_second)
{
assert(_iterator_is_valid(it_first));
assert(_iterator_is_valid(it_second));
if (it_first._t_containertype == it_second._t_containertype &&
it_first._t_iteratortype == it_second._t_iteratortype) {
return true;
} else {
return false;
}
}
/**
* Move iterator to prev n position.
*/
iterator_t iterator_prev_n(iterator_t it_iter, int n_step)
{
assert(_iterator_is_valid(it_iter));
assert(_iterator_limit_type(it_iter, _RANDOM_ACCESS_ITERATOR));
if (n_step == 0) {
return it_iter;
}
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
return _vector_iterator_prev_n(it_iter, n_step);
break;
case _DEQUE_CONTAINER:
return _deque_iterator_prev_n(it_iter, n_step);
break;
case _BASIC_STRING_CONTAINER:
return _basic_string_iterator_prev_n(it_iter, n_step);
break;
default:
assert(false);
return it_iter;
break;
}
}
/**
* Set value that pointed by iterator.
*/
void iterator_set_value(iterator_t it_iter, const void* cpv_value)
{
assert(cpv_value != NULL);
assert(_iterator_is_valid(it_iter));
assert(_iterator_limit_type(it_iter, _OUTPUT_ITERATOR));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
_vector_iterator_set_value(it_iter, cpv_value);
break;
case _LIST_CONTAINER:
_list_iterator_set_value(it_iter, cpv_value);
break;
case _DEQUE_CONTAINER:
_deque_iterator_set_value(it_iter, cpv_value);
break;
/*
case _SLIST_CONTAINER:
_slist_iterator_set_value(it_iter, cpv_value);
break;
*/
case _BASIC_STRING_CONTAINER:
_basic_string_iterator_set_value(it_iter, cpv_value);
break;
default:
assert(false);
break;
}
}
/**
* Test two iterator are equal or not.
*/
bool_t iterator_equal(iterator_t it_first, iterator_t it_second)
{
assert(_iterator_is_valid(it_first));
assert(_iterator_is_valid(it_second));
assert(_iterator_limit_type(it_first, _INPUT_ITERATOR));
assert(_iterator_limit_type(it_second, _INPUT_ITERATOR));
if (it_first._t_containertype != it_second._t_containertype) {
return false;
}
switch (it_first._t_containertype) {
case _VECTOR_CONTAINER:
return _vector_iterator_equal(it_first, it_second);
break;
case _LIST_CONTAINER:
return _list_iterator_equal(it_first, it_second);
break;
case _DEQUE_CONTAINER:
return _deque_iterator_equal(it_first, it_second);
break;
/*
case _SLIST_CONTAINER:
return _slist_iterator_equal(it_first, it_second);
break;
*/
case _SET_CONTAINER:
return _set_iterator_equal(it_first, it_second);
break;
case _MAP_CONTAINER:
return _map_iterator_equal(it_first, it_second);
break;
case _HASH_SET_CONTAINER:
return _hash_set_iterator_equal(it_first, it_second);
break;
case _HASH_MAP_CONTAINER:
return _hash_map_iterator_equal(it_first, it_second);
break;
case _BASIC_STRING_CONTAINER:
return _basic_string_iterator_equal(it_first, it_second);
break;
default:
assert(false);
return false;
break;
}
}
/**
* Test the type that saved in the avl tree container and referenced by it_iter are same.
*/
bool_t _avl_tree_same_iterator_type(const _avl_tree_t* cpt_avl_tree, iterator_t it_iter)
{
assert(cpt_avl_tree != NULL);
assert(_avl_tree_is_inited(cpt_avl_tree) || _avl_tree_is_created(cpt_avl_tree));
assert(_iterator_is_valid(it_iter));
return _type_is_same_ex(&cpt_avl_tree->_t_typeinfo, _iterator_get_typeinfo(it_iter));
}
/**
* Test the type that saved in the vector container and referenced by it_iter are same.
*/
bool_t _vector_same_iterator_type(const vector_t* cpvec_vector, iterator_t it_iter)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector) || _vector_is_created(cpvec_vector));
assert(_iterator_is_valid(it_iter));
return _type_is_same_ex(&cpvec_vector->_t_typeinfo, _iterator_get_typeinfo(it_iter));
}
/**
* Iterator distance.
*/
int iterator_minus(iterator_t it_first, iterator_t it_second)
{
assert(_iterator_is_valid(it_first));
assert(_iterator_is_valid(it_second));
assert(_iterator_limit_type(it_first, _RANDOM_ACCESS_ITERATOR));
switch (it_first._t_containertype) {
case _VECTOR_CONTAINER:
return _vector_iterator_minus(it_first, it_second);
break;
case _DEQUE_CONTAINER:
return _deque_iterator_minus(it_first, it_second);
break;
case _BASIC_STRING_CONTAINER:
return _basic_string_iterator_minus(it_first, it_second);
break;
default:
assert(false);
return 0;
break;
}
}
/**
* Get pointer that pointed by iterator, but ignore char*.
*/
const void* _iterator_get_pointer_ignore_cstr(iterator_t it_iter)
{
assert(_iterator_is_valid(it_iter));
assert(_iterator_limit_type(it_iter, _INPUT_ITERATOR));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
return _vector_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _LIST_CONTAINER:
return _list_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _DEQUE_CONTAINER:
return _deque_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _SLIST_CONTAINER:
return _slist_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _SET_CONTAINER:
return _set_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _MULTISET_CONTAINER:
return _multiset_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _MAP_CONTAINER:
return _map_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _MULTIMAP_CONTAINER:
return _multimap_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _HASH_SET_CONTAINER:
return _hash_set_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _HASH_MULTISET_CONTAINER:
return _hash_multiset_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _HASH_MAP_CONTAINER:
return _hash_map_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _HASH_MULTIMAP_CONTAINER:
return _hash_multimap_iterator_get_pointer_ignore_cstr(it_iter);
break;
case _BASIC_STRING_CONTAINER:
return _basic_string_iterator_get_pointer_ignore_cstr(it_iter);
break;
default:
assert(false);
return NULL;
break;
}
}
/**
* Iterator distance for all iterator type.
*/
int iterator_distance(iterator_t it_first, iterator_t it_second)
{
assert(_iterator_is_valid(it_first));
assert(_iterator_is_valid(it_second));
assert(_iterator_same_type(it_first, it_second));
switch (it_first._t_containertype) {
case _VECTOR_CONTAINER:
case _DEQUE_CONTAINER:
case _BASIC_STRING_CONTAINER:
return iterator_minus(it_second, it_first);
break;
case _LIST_CONTAINER:
return _list_iterator_distance(it_first, it_second);
break;
/*
case _SLIST_CONTAINER:
return _slist_iterator_distance(it_first, it_second);
break;
*/
case _SET_CONTAINER:
return _set_iterator_distance(it_first, it_second);
break;
case _MAP_CONTAINER:
return _map_iterator_distance(it_first, it_second);
break;
case _HASH_SET_CONTAINER:
return _hash_set_iterator_distance(it_first, it_second);
break;
case _HASH_MAP_CONTAINER:
return _hash_map_iterator_distance(it_first, it_second);
break;
default:
assert(false);
return 0;
break;
}
}
/**
* Get typeinfo of iterator.
*/
_typeinfo_t* _iterator_get_typeinfo(iterator_t it_iter)
{
assert(_iterator_is_valid(it_iter));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
return &((vector_t*)it_iter._pt_container)->_t_typeinfo;
break;
case _DEQUE_CONTAINER:
return &((deque_t*)it_iter._pt_container)->_t_typeinfo;
break;
case _BASIC_STRING_CONTAINER:
return &((basic_string_t*)it_iter._pt_container)->_vec_base._t_typeinfo;
break;
case _LIST_CONTAINER:
return &((list_t*)it_iter._pt_container)->_t_typeinfo;
break;
case _SLIST_CONTAINER:
return &((slist_t*)it_iter._pt_container)->_t_typeinfo;
break;
case _SET_CONTAINER:
return &((set_t*)it_iter._pt_container)->_t_tree._t_typeinfo;
break;
case _MULTISET_CONTAINER:
return &((multiset_t*)it_iter._pt_container)->_t_tree._t_typeinfo;
break;
case _MAP_CONTAINER:
return &((map_t*)it_iter._pt_container)->_t_tree._t_typeinfo;
break;
case _MULTIMAP_CONTAINER:
return &((multimap_t*)it_iter._pt_container)->_t_tree._t_typeinfo;
break;
case _HASH_SET_CONTAINER:
return &((hash_set_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo;
break;
case _HASH_MULTISET_CONTAINER:
return &((hash_multiset_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo;
break;
case _HASH_MAP_CONTAINER:
return &((hash_map_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo;
break;
case _HASH_MULTIMAP_CONTAINER:
return &((hash_multimap_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo;
break;
default:
assert(false);
return NULL;
break;
}
}
/**
* Test whether the iterator type of restriction.
*/
bool_t _iterator_limit_type(iterator_t it_iter, iteratortype_t t_limittype)
{
assert(_iterator_is_valid(it_iter));
/* check iterator type */
switch (t_limittype) {
case _INPUT_ITERATOR:
if (it_iter._t_iteratortype == _RANDOM_ACCESS_ITERATOR ||
it_iter._t_iteratortype == _BIDIRECTIONAL_ITERATOR ||
it_iter._t_iteratortype == _FORWARD_ITERATOR ||
it_iter._t_iteratortype == _INPUT_ITERATOR) {
return true;
}
break;
case _OUTPUT_ITERATOR:
if (it_iter._t_iteratortype == _RANDOM_ACCESS_ITERATOR ||
it_iter._t_iteratortype == _BIDIRECTIONAL_ITERATOR ||
it_iter._t_iteratortype == _FORWARD_ITERATOR ||
it_iter._t_iteratortype == _OUTPUT_ITERATOR) {
return true;
}
break;
case _FORWARD_ITERATOR:
if (it_iter._t_iteratortype == _RANDOM_ACCESS_ITERATOR ||
it_iter._t_iteratortype == _BIDIRECTIONAL_ITERATOR ||
it_iter._t_iteratortype == _FORWARD_ITERATOR) {
return true;
}
break;
case _BIDIRECTIONAL_ITERATOR:
if (it_iter._t_iteratortype == _RANDOM_ACCESS_ITERATOR ||
it_iter._t_iteratortype == _BIDIRECTIONAL_ITERATOR) {
return true;
}
break;
case _RANDOM_ACCESS_ITERATOR:
if (it_iter._t_iteratortype == _RANDOM_ACCESS_ITERATOR) {
return true;
}
break;
default:
assert(false);
break;
}
return false;
}
/**
* Get value that pointed by iterator.
*/
void iterator_get_value(iterator_t it_iter, void* pv_value)
{
assert(pv_value != NULL);
assert(_iterator_is_valid(it_iter));
assert(_iterator_limit_type(it_iter, _INPUT_ITERATOR));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
_vector_iterator_get_value(it_iter, pv_value);
break;
case _LIST_CONTAINER:
_list_iterator_get_value(it_iter, pv_value);
break;
case _DEQUE_CONTAINER:
_deque_iterator_get_value(it_iter, pv_value);
break;
/*
case _SLIST_CONTAINER:
_slist_iterator_get_value(it_iter, pv_value);
break;
*/
case _SET_CONTAINER:
_set_iterator_get_value(it_iter, pv_value);
break;
case _MAP_CONTAINER:
_map_iterator_get_value(it_iter, pv_value);
break;
case _HASH_SET_CONTAINER:
_hash_set_iterator_get_value(it_iter, pv_value);
break;
case _HASH_MAP_CONTAINER:
_hash_map_iterator_get_value(it_iter, pv_value);
break;
case _BASIC_STRING_CONTAINER:
_basic_string_iterator_get_value(it_iter, pv_value);
break;
default:
assert(false);
break;
}
}
/**
* Element random access.
*/
void* iterator_at(iterator_t it_iter, int n_index)
{
assert(_iterator_is_valid(it_iter));
assert(_iterator_limit_type(it_iter, _RANDOM_ACCESS_ITERATOR));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
return _vector_iterator_at(it_iter, n_index);
break;
case _DEQUE_CONTAINER:
return _deque_iterator_at(it_iter, n_index);
break;
case _BASIC_STRING_CONTAINER:
return _basic_string_iterator_at(it_iter, n_index);
break;
default:
assert(false);
return NULL;
break;
}
}
/**
* Move iterator to next position.
*/
iterator_t iterator_next(iterator_t it_iter)
{
assert(_iterator_is_valid(it_iter));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
return _vector_iterator_next(it_iter);
break;
case _LIST_CONTAINER:
return _list_iterator_next(it_iter);
break;
case _DEQUE_CONTAINER:
return _deque_iterator_next(it_iter);
break;
/*
case _SLIST_CONTAINER:
return _slist_iterator_next(it_iter);
break;
*/
case _SET_CONTAINER:
return _set_iterator_next(it_iter);
break;
case _MAP_CONTAINER:
return _map_iterator_next(it_iter);
break;
case _HASH_SET_CONTAINER:
return _hash_set_iterator_next(it_iter);
break;
case _HASH_MAP_CONTAINER:
return _hash_map_iterator_next(it_iter);
break;
case _BASIC_STRING_CONTAINER:
return _basic_string_iterator_next(it_iter);
break;
default:
assert(false);
return it_iter;
break;
}
}
/**
* Move iterator to previous position.
*/
iterator_t iterator_prev(iterator_t it_iter)
{
assert(_iterator_is_valid(it_iter));
assert(_iterator_limit_type(it_iter, _BIDIRECTIONAL_ITERATOR));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
return _vector_iterator_prev(it_iter);
break;
case _LIST_CONTAINER:
return _list_iterator_prev(it_iter);
break;
case _DEQUE_CONTAINER:
return _deque_iterator_prev(it_iter);
break;
case _SET_CONTAINER:
return _set_iterator_prev(it_iter);
break;
case _MAP_CONTAINER:
return _map_iterator_prev(it_iter);
break;
case _BASIC_STRING_CONTAINER:
return _basic_string_iterator_prev(it_iter);
break;
case _HASH_SET_CONTAINER:
return _hash_set_iterator_prev(it_iter);
break;
case _HASH_MAP_CONTAINER:
return _hash_map_iterator_prev(it_iter);
break;
default:
assert(false);
return it_iter;
break;
}
}
/**
* Select binary function accroding to binary function type.
*/
bfun_t _fun_get_binary(iterator_t it_iter, fun_type_t ftype_type)
{
const char* s_typename = NULL;
_typeinfo_t* pt_typeinfo = NULL;
assert(_iterator_is_valid(it_iter));
assert(ftype_type >= _PLUS_FUN && ftype_type <= _LOGICAL_OR_FUN);
s_typename = _iterator_get_typebasename(it_iter);
pt_typeinfo = _iterator_get_typeinfo(it_iter);
if (s_typename == NULL) {
return fun_default_binary;
}
if (strncmp(s_typename, _CHAR_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_CHAR_TYPE, _TYPE_NAME_SIZE) == 0) { /* char */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_char; break;
case _MINUS_FUN: return fun_minus_char; break;
case _MULTIPLIES_FUN: return fun_multiplies_char; break;
case _DIVIDES_FUN: return fun_divides_char; break;
case _MODULUS_FUN: return fun_modulus_char; break;
case _EQUAL_FUN: return fun_equal_char; break;
case _NOT_EQUAL_FUN: return fun_not_equal_char; break;
case _GREATER_FUN: return fun_greater_char; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_char; break;
case _LESS_FUN: return fun_less_char; break;
case _LESS_EQUAL_FUN: return fun_less_equal_char; break;
default: break;
}
} else if (strncmp(s_typename, _UNSIGNED_CHAR_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned char */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_uchar; break;
case _MINUS_FUN: return fun_minus_uchar; break;
case _MULTIPLIES_FUN: return fun_multiplies_uchar; break;
case _DIVIDES_FUN: return fun_divides_uchar; break;
case _MODULUS_FUN: return fun_modulus_uchar; break;
case _EQUAL_FUN: return fun_equal_uchar; break;
case _NOT_EQUAL_FUN: return fun_not_equal_uchar; break;
case _GREATER_FUN: return fun_greater_uchar; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_uchar; break;
case _LESS_FUN: return fun_less_uchar; break;
case _LESS_EQUAL_FUN: return fun_less_equal_uchar; break;
default: break;
}
} else if (strncmp(s_typename, _SHORT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SHORT_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_SHORT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_SHORT_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* short */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_short; break;
case _MINUS_FUN: return fun_minus_short; break;
case _MULTIPLIES_FUN: return fun_multiplies_short; break;
case _DIVIDES_FUN: return fun_divides_short; break;
case _MODULUS_FUN: return fun_modulus_short; break;
case _EQUAL_FUN: return fun_equal_short; break;
case _NOT_EQUAL_FUN: return fun_not_equal_short; break;
case _GREATER_FUN: return fun_greater_short; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_short; break;
case _LESS_FUN: return fun_less_short; break;
case _LESS_EQUAL_FUN: return fun_less_equal_short; break;
default: break;
}
} else if (strncmp(s_typename, _UNSIGNED_SHORT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_SHORT_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned short */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_ushort; break;
case _MINUS_FUN: return fun_minus_ushort; break;
case _MULTIPLIES_FUN: return fun_multiplies_ushort; break;
case _DIVIDES_FUN: return fun_divides_ushort; break;
case _MODULUS_FUN: return fun_modulus_ushort; break;
case _EQUAL_FUN: return fun_equal_ushort; break;
case _NOT_EQUAL_FUN: return fun_not_equal_ushort; break;
case _GREATER_FUN: return fun_greater_ushort; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_ushort; break;
case _LESS_FUN: return fun_less_ushort; break;
case _LESS_EQUAL_FUN: return fun_less_equal_ushort; break;
default: break;
}
} else if (strncmp(s_typename, _INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_TYPE, _TYPE_NAME_SIZE) == 0) { /* int */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_int; break;
case _MINUS_FUN: return fun_minus_int; break;
case _MULTIPLIES_FUN: return fun_multiplies_int; break;
case _DIVIDES_FUN: return fun_divides_int; break;
case _MODULUS_FUN: return fun_modulus_int; break;
case _EQUAL_FUN: return fun_equal_int; break;
case _NOT_EQUAL_FUN: return fun_not_equal_int; break;
case _GREATER_FUN: return fun_greater_int; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_int; break;
case _LESS_FUN: return fun_less_int; break;
case _LESS_EQUAL_FUN: return fun_less_equal_int; break;
default: break;
}
} else if (strncmp(s_typename, _UNSIGNED_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned int */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_uint; break;
case _MINUS_FUN: return fun_minus_uint; break;
case _MULTIPLIES_FUN: return fun_multiplies_uint; break;
case _DIVIDES_FUN: return fun_divides_uint; break;
case _MODULUS_FUN: return fun_modulus_uint; break;
case _EQUAL_FUN: return fun_equal_uint; break;
case _NOT_EQUAL_FUN: return fun_not_equal_uint; break;
case _GREATER_FUN: return fun_greater_uint; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_uint; break;
case _LESS_FUN: return fun_less_uint; break;
case _LESS_EQUAL_FUN: return fun_less_equal_uint; break;
default: break;
}
} else if (strncmp(s_typename, _LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* long */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_long; break;
case _MINUS_FUN: return fun_minus_long; break;
case _MULTIPLIES_FUN: return fun_multiplies_long; break;
case _DIVIDES_FUN: return fun_divides_long; break;
case _MODULUS_FUN: return fun_modulus_long; break;
case _EQUAL_FUN: return fun_equal_long; break;
case _NOT_EQUAL_FUN: return fun_not_equal_long; break;
case _GREATER_FUN: return fun_greater_long; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_long; break;
case _LESS_FUN: return fun_less_long; break;
case _LESS_EQUAL_FUN: return fun_less_equal_long; break;
default: break;
}
} else if (strncmp(s_typename, _UNSIGNED_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned long */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_ulong; break;
case _MINUS_FUN: return fun_minus_ulong; break;
case _MULTIPLIES_FUN: return fun_multiplies_ulong; break;
case _DIVIDES_FUN: return fun_divides_ulong; break;
case _MODULUS_FUN: return fun_modulus_ulong; break;
case _EQUAL_FUN: return fun_equal_ulong; break;
case _NOT_EQUAL_FUN: return fun_not_equal_ulong; break;
case _GREATER_FUN: return fun_greater_ulong; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_ulong; break;
case _LESS_FUN: return fun_less_ulong; break;
case _LESS_EQUAL_FUN: return fun_less_equal_ulong; break;
default: break;
}
} else if (strncmp(s_typename, _FLOAT_TYPE, _TYPE_NAME_SIZE) == 0) { /* float */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_float; break;
case _MINUS_FUN: return fun_minus_float; break;
case _MULTIPLIES_FUN: return fun_multiplies_float; break;
case _DIVIDES_FUN: return fun_divides_float; break;
case _EQUAL_FUN: return fun_equal_float; break;
case _NOT_EQUAL_FUN: return fun_not_equal_float; break;
case _GREATER_FUN: return fun_greater_float; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_float; break;
case _LESS_FUN: return fun_less_float; break;
case _LESS_EQUAL_FUN: return fun_less_equal_float; break;
default: break;
}
} else if (strncmp(s_typename, _DOUBLE_TYPE, _TYPE_NAME_SIZE) == 0) { /* double */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_double; break;
case _MINUS_FUN: return fun_minus_double; break;
case _MULTIPLIES_FUN: return fun_multiplies_double; break;
case _DIVIDES_FUN: return fun_divides_double; break;
case _EQUAL_FUN: return fun_equal_double; break;
case _NOT_EQUAL_FUN: return fun_not_equal_double; break;
case _GREATER_FUN: return fun_greater_double; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_double; break;
case _LESS_FUN: return fun_less_double; break;
case _LESS_EQUAL_FUN: return fun_less_equal_double; break;
default: break;
}
} else if (strncmp(s_typename, _LONG_DOUBLE_TYPE, _TYPE_NAME_SIZE) == 0) { /* long double */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_long_double; break;
case _MINUS_FUN: return fun_minus_long_double; break;
case _MULTIPLIES_FUN: return fun_multiplies_long_double; break;
case _DIVIDES_FUN: return fun_divides_long_double; break;
case _EQUAL_FUN: return fun_equal_long_double; break;
case _NOT_EQUAL_FUN: return fun_not_equal_long_double; break;
case _GREATER_FUN: return fun_greater_long_double; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_long_double; break;
case _LESS_FUN: return fun_less_long_double; break;
case _LESS_EQUAL_FUN: return fun_less_equal_long_double; break;
default: break;
}
} else if (strncmp(s_typename, _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) { /* c-string */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_cstr; break;
case _NOT_EQUAL_FUN: return fun_not_equal_cstr; break;
case _GREATER_FUN: return fun_greater_cstr; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_cstr; break;
case _LESS_FUN: return fun_less_cstr; break;
case _LESS_EQUAL_FUN: return fun_less_equal_cstr; break;
default: break;
}
} else if (strncmp(s_typename, _POINTER_TYPE, _TYPE_NAME_SIZE) == 0) { /* void* */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_pointer; break;
case _NOT_EQUAL_FUN: return fun_not_equal_pointer; break;
case _GREATER_FUN: return fun_greater_pointer; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_pointer; break;
case _LESS_FUN: return fun_less_pointer; break;
case _LESS_EQUAL_FUN: return fun_less_equal_pointer; break;
default: break;
}
} else if (strncmp(s_typename, _CSTL_BOOL_TYPE, _TYPE_NAME_SIZE) == 0) { /* bool_t */
switch (ftype_type) {
case _LOGICAL_AND_FUN: return fun_logical_and_cstl_bool; break;
case _LOGICAL_OR_FUN: return fun_logical_or_cstl_bool; break;
default: break;
}
#ifndef _MSC_VER
} else if (strncmp(s_typename, _BOOL_TYPE, _TYPE_NAME_SIZE) == 0) { /* _Bool */
switch (ftype_type) {
case _LOGICAL_AND_FUN: return fun_logical_and_bool; break;
case _LOGICAL_OR_FUN: return fun_logical_or_bool; break;
default: break;
}
} else if (strncmp(s_typename, _LONG_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _LONG_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* long long */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_long_long; break;
case _MINUS_FUN: return fun_minus_long_long; break;
case _MULTIPLIES_FUN: return fun_multiplies_long_long; break;
case _DIVIDES_FUN: return fun_divides_long_long; break;
case _MODULUS_FUN: return fun_modulus_long_long; break;
case _EQUAL_FUN: return fun_equal_long_long; break;
case _NOT_EQUAL_FUN: return fun_not_equal_long_long; break;
case _GREATER_FUN: return fun_greater_long_long; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_long_long; break;
case _LESS_FUN: return fun_less_long_long; break;
case _LESS_EQUAL_FUN: return fun_less_equal_long_long; break;
default: break;
}
} else if (strncmp(s_typename, _UNSIGNED_LONG_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_LONG_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) {/* unsigned long long */
switch (ftype_type) {
case _PLUS_FUN: return fun_plus_ulong_long; break;
case _MINUS_FUN: return fun_minus_ulong_long; break;
case _MULTIPLIES_FUN: return fun_multiplies_ulong_long; break;
case _DIVIDES_FUN: return fun_divides_ulong_long; break;
case _MODULUS_FUN: return fun_modulus_ulong_long; break;
case _EQUAL_FUN: return fun_equal_ulong_long; break;
case _NOT_EQUAL_FUN: return fun_not_equal_ulong_long; break;
case _GREATER_FUN: return fun_greater_ulong_long; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_ulong_long; break;
case _LESS_FUN: return fun_less_ulong_long; break;
case _LESS_EQUAL_FUN: return fun_less_equal_ulong_long; break;
default: break;
}
#endif
} else if (strncmp(s_typename, _VECTOR_TYPE, _TYPE_NAME_SIZE) == 0) { /* vector_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_vector; break;
case _NOT_EQUAL_FUN: return fun_not_equal_vector; break;
case _GREATER_FUN: return fun_greater_vector; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_vector; break;
case _LESS_FUN: return fun_less_vector; break;
case _LESS_EQUAL_FUN: return fun_less_equal_vector; break;
default: break;
}
} else if (strncmp(s_typename, _DEQUE_TYPE, _TYPE_NAME_SIZE) == 0) { /* deque_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_deque; break;
case _NOT_EQUAL_FUN: return fun_not_equal_deque; break;
case _GREATER_FUN: return fun_greater_deque; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_deque; break;
case _LESS_FUN: return fun_less_deque; break;
case _LESS_EQUAL_FUN: return fun_less_equal_deque; break;
default: break;
}
} else if (strncmp(s_typename, _LIST_TYPE, _TYPE_NAME_SIZE) == 0) { /* list_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_list; break;
case _NOT_EQUAL_FUN: return fun_not_equal_list; break;
case _GREATER_FUN: return fun_greater_list; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_list; break;
case _LESS_FUN: return fun_less_list; break;
case _LESS_EQUAL_FUN: return fun_less_equal_list; break;
default: break;
}
} else if (strncmp(s_typename, _SLIST_TYPE, _TYPE_NAME_SIZE) == 0) { /* slist_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_slist; break;
case _NOT_EQUAL_FUN: return fun_not_equal_slist; break;
case _GREATER_FUN: return fun_greater_slist; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_slist; break;
case _LESS_FUN: return fun_less_slist; break;
case _LESS_EQUAL_FUN: return fun_less_equal_slist; break;
default: break;
}
} else if (strncmp(s_typename, _QUEUE_TYPE, _TYPE_NAME_SIZE) == 0) { /* queue_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_queue; break;
case _NOT_EQUAL_FUN: return fun_not_equal_queue; break;
case _GREATER_FUN: return fun_greater_queue; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_queue; break;
case _LESS_FUN: return fun_less_queue; break;
case _LESS_EQUAL_FUN: return fun_less_equal_queue; break;
default: break;
}
} else if (strncmp(s_typename, _STACK_TYPE, _TYPE_NAME_SIZE) == 0) { /* stack_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_stack; break;
case _NOT_EQUAL_FUN: return fun_not_equal_stack; break;
case _GREATER_FUN: return fun_greater_stack; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_stack; break;
case _LESS_FUN: return fun_less_stack; break;
case _LESS_EQUAL_FUN: return fun_less_equal_stack; break;
default: break;
}
} else if (strncmp(s_typename, _PAIR_TYPE, _TYPE_NAME_SIZE) == 0) { /* pair_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_pair; break;
case _NOT_EQUAL_FUN: return fun_not_equal_pair; break;
case _GREATER_FUN: return fun_greater_pair; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_pair; break;
case _LESS_FUN: return fun_less_pair; break;
case _LESS_EQUAL_FUN: return fun_less_equal_pair; break;
default: break;
}
} else if (strncmp(s_typename, _SET_TYPE, _TYPE_NAME_SIZE) == 0) { /* set_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_set; break;
case _NOT_EQUAL_FUN: return fun_not_equal_set; break;
case _GREATER_FUN: return fun_greater_set; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_set; break;
case _LESS_FUN: return fun_less_set; break;
case _LESS_EQUAL_FUN: return fun_less_equal_set; break;
default: break;
}
} else if (strncmp(s_typename, _MAP_TYPE, _TYPE_NAME_SIZE) == 0) { /* map_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_map; break;
case _NOT_EQUAL_FUN: return fun_not_equal_map; break;
case _GREATER_FUN: return fun_greater_map; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_map; break;
case _LESS_FUN: return fun_less_map; break;
case _LESS_EQUAL_FUN: return fun_less_equal_map; break;
default: break;
}
} else if (strncmp(s_typename, _MULTISET_TYPE, _TYPE_NAME_SIZE) == 0) { /* multiset_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_multiset; break;
case _NOT_EQUAL_FUN: return fun_not_equal_multiset; break;
case _GREATER_FUN: return fun_greater_multiset; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_multiset; break;
case _LESS_FUN: return fun_less_multiset; break;
case _LESS_EQUAL_FUN: return fun_less_equal_multiset; break;
default: break;
}
} else if (strncmp(s_typename, _MULTIMAP_TYPE, _TYPE_NAME_SIZE) == 0) { /* multimap_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_multimap; break;
case _NOT_EQUAL_FUN: return fun_not_equal_multimap; break;
case _GREATER_FUN: return fun_greater_multimap; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_multimap; break;
case _LESS_FUN: return fun_less_multimap; break;
case _LESS_EQUAL_FUN: return fun_less_equal_multimap; break;
default: break;
}
} else if (strncmp(s_typename, _HASH_SET_TYPE, _TYPE_NAME_SIZE) == 0) { /* hash_set_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_hash_set; break;
case _NOT_EQUAL_FUN: return fun_not_equal_hash_set; break;
case _GREATER_FUN: return fun_greater_hash_set; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_hash_set; break;
case _LESS_FUN: return fun_less_hash_set; break;
case _LESS_EQUAL_FUN: return fun_less_equal_hash_set; break;
default: break;
}
} else if (strncmp(s_typename, _HASH_MAP_TYPE, _TYPE_NAME_SIZE) == 0) { /* hash_map_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_hash_map; break;
case _NOT_EQUAL_FUN: return fun_not_equal_hash_map; break;
case _GREATER_FUN: return fun_greater_hash_map; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_hash_map; break;
case _LESS_FUN: return fun_less_hash_map; break;
case _LESS_EQUAL_FUN: return fun_less_equal_hash_map; break;
default: break;
}
} else if (strncmp(s_typename, _HASH_MULTISET_TYPE, _TYPE_NAME_SIZE) == 0) { /* hash_multiset_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_hash_multiset; break;
case _NOT_EQUAL_FUN: return fun_not_equal_hash_multiset; break;
case _GREATER_FUN: return fun_greater_hash_multiset; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_hash_multiset; break;
case _LESS_FUN: return fun_less_hash_multiset; break;
case _LESS_EQUAL_FUN: return fun_less_equal_hash_multiset; break;
default: break;
}
} else if (strncmp(s_typename, _HASH_MULTIMAP_TYPE, _TYPE_NAME_SIZE) == 0) { /* hash_multimap_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_hash_multimap; break;
case _NOT_EQUAL_FUN: return fun_not_equal_hash_multimap; break;
case _GREATER_FUN: return fun_greater_hash_multimap; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_hash_multimap; break;
case _LESS_FUN: return fun_less_hash_multimap; break;
case _LESS_EQUAL_FUN: return fun_less_equal_hash_multimap; break;
default: break;
}
} else if (strncmp(s_typename, _STRING_TYPE, _TYPE_NAME_SIZE) == 0) { /* string_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_string; break;
case _NOT_EQUAL_FUN: return fun_not_equal_string; break;
case _GREATER_FUN: return fun_greater_string; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_string; break;
case _LESS_FUN: return fun_less_string; break;
case _LESS_EQUAL_FUN: return fun_less_equal_string; break;
default: break;
}
} else if (strncmp(s_typename, _BASIC_STRING_TYPE, _TYPE_NAME_SIZE) == 0) { /* basic_string_t */
switch (ftype_type) {
case _EQUAL_FUN: return fun_equal_basic_string; break;
case _NOT_EQUAL_FUN: return fun_not_equal_basic_string; break;
case _GREATER_FUN: return fun_greater_basic_string; break;
case _GREATER_EQUAL_FUN: return fun_greater_equal_basic_string; break;
case _LESS_FUN: return fun_less_basic_string; break;
case _LESS_EQUAL_FUN: return fun_less_equal_basic_string; break;
default: break;
}
}
if (pt_typeinfo != NULL && pt_typeinfo->_pt_type != NULL &&
pt_typeinfo->_t_style == _TYPE_USER_DEFINE && ftype_type == _LESS_FUN) {
return pt_typeinfo->_pt_type->_t_typeless;
}
return fun_default_binary;
}
/**
* Destroy and deallocate element allocated and initialized by _iterator_allocate_init_elem().
*/
void _iterator_deallocate_destroy_elem(iterator_t it_iter, void* pv_value)
{
bool_t b_result = false;
assert(_iterator_is_valid(it_iter));
assert(pv_value != NULL);
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
((vector_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((vector_t*)it_iter._pt_container)->_t_allocator, pv_value,
((vector_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
break;
case _DEQUE_CONTAINER:
((deque_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((deque_t*)it_iter._pt_container)->_t_allocator, pv_value,
((deque_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
break;
case _BASIC_STRING_CONTAINER:
((basic_string_t*)it_iter._pt_container)->_vec_base._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((basic_string_t*)it_iter._pt_container)->_vec_base._t_allocator, pv_value,
((basic_string_t*)it_iter._pt_container)->_vec_base._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _LIST_CONTAINER:
((list_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((list_t*)it_iter._pt_container)->_t_allocator, pv_value,
((list_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
break;
case _SLIST_CONTAINER:
((slist_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((slist_t*)it_iter._pt_container)->_t_allocator, pv_value,
((slist_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
break;
case _SET_CONTAINER:
((set_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((set_t*)it_iter._pt_container)->_t_tree._t_allocator, pv_value,
((set_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _MULTISET_CONTAINER:
((multiset_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((multiset_t*)it_iter._pt_container)->_t_tree._t_allocator, pv_value,
((set_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _MAP_CONTAINER:
((map_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((map_t*)it_iter._pt_container)->_t_tree._t_allocator, pv_value,
((map_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _MULTIMAP_CONTAINER:
((multimap_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((multimap_t*)it_iter._pt_container)->_t_tree._t_allocator, pv_value,
((multimap_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _HASH_SET_CONTAINER:
((hash_set_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((hash_set_t*)it_iter._pt_container)->_t_hashtable._t_allocator, pv_value,
((hash_set_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _HASH_MULTISET_CONTAINER:
((hash_multiset_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((hash_multiset_t*)it_iter._pt_container)->_t_hashtable._t_allocator, pv_value,
((hash_multiset_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _HASH_MAP_CONTAINER:
((hash_map_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((hash_map_t*)it_iter._pt_container)->_t_hashtable._t_allocator, pv_value,
((hash_map_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
break;
case _HASH_MULTIMAP_CONTAINER:
((hash_multimap_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typedestroy(pv_value, &b_result);
assert(b_result);
_alloc_deallocate(&((hash_multimap_t*)it_iter._pt_container)->_t_hashtable._t_allocator, pv_value,
((hash_multimap_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
break;
default:
assert(false);
break;
}
}
/**
* Select unary function accroding to unary function type.
*/
ufun_t _fun_get_unary(iterator_t it_iter, fun_type_t ftype_type)
{
const char* s_typename = NULL;
assert(_iterator_is_valid(it_iter));
assert(ftype_type >= _NEGATE_FUN && ftype_type <= _RANDOM_NUMBER_FUN);
if ((s_typename = _iterator_get_typebasename(it_iter))== NULL) {
return fun_default_unary;
}
if (strncmp(s_typename, _CHAR_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_CHAR_TYPE, _TYPE_NAME_SIZE) == 0) { /* char */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_char;
} else if (ftype_type == _INCREASE_FUN) {
return _fun_increase_char;
}
} else if (strncmp(s_typename, _UNSIGNED_CHAR_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned char */
if (ftype_type == _INCREASE_FUN) {
return _fun_increase_uchar;
}
} else if (strncmp(s_typename, _SHORT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SHORT_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_SHORT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_SHORT_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* short */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_short;
} else if (ftype_type == _INCREASE_FUN) {
return _fun_increase_short;
}
} else if (strncmp(s_typename, _UNSIGNED_SHORT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_SHORT_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned short */
if (ftype_type == _INCREASE_FUN) {
return _fun_increase_ushort;
}
} else if (strncmp(s_typename, _INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_TYPE, _TYPE_NAME_SIZE) == 0) { /* int */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_int;
} else if (ftype_type == _INCREASE_FUN) {
return _fun_increase_int;
}
} else if (strncmp(s_typename, _UNSIGNED_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned int */
if (ftype_type == _INCREASE_FUN) {
return _fun_increase_uint;
}
} else if (strncmp(s_typename, _LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* long */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_long;
} else if (ftype_type == _INCREASE_FUN) {
return _fun_increase_long;
}
} else if (strncmp(s_typename, _UNSIGNED_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned long */
if (ftype_type == _INCREASE_FUN) {
return _fun_increase_ulong;
}
} else if (strncmp(s_typename, _FLOAT_TYPE, _TYPE_NAME_SIZE) == 0) { /* float */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_float;
} else if (ftype_type == _INCREASE_FUN) {
return _fun_increase_float;
}
} else if (strncmp(s_typename, _DOUBLE_TYPE, _TYPE_NAME_SIZE) == 0) { /* double */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_double;
} else if (ftype_type == _INCREASE_FUN) {
return _fun_increase_double;
}
} else if (strncmp(s_typename, _LONG_DOUBLE_TYPE, _TYPE_NAME_SIZE) == 0) { /* long double */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_long_double;
}
} else if (strncmp(s_typename, _CSTL_BOOL_TYPE, _TYPE_NAME_SIZE) == 0) { /* bool_t */
if (ftype_type == _LOGICAL_NOT_FUN) {
return fun_logical_not_cstl_bool;
}
#ifndef _MSC_VER
} else if (strncmp(s_typename, _BOOL_TYPE, _TYPE_NAME_SIZE) == 0) { /* _Bool */
if (ftype_type == _LOGICAL_NOT_FUN) {
return fun_logical_not_bool;
}
} else if (strncmp(s_typename, _LONG_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _LONG_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _SIGNED_LONG_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* long */
if (ftype_type == _NEGATE_FUN) {
return fun_negate_long_long;
} else if (ftype_type == _INCREASE_FUN) {
return _fun_increase_long_long;
}
} else if (strncmp(s_typename, _UNSIGNED_LONG_LONG_TYPE, _TYPE_NAME_SIZE) == 0 ||
strncmp(s_typename, _UNSIGNED_LONG_LONG_INT_TYPE, _TYPE_NAME_SIZE) == 0) { /* unsigned long */
if (ftype_type == _INCREASE_FUN) {
return _fun_increase_ulong_long;
}
#endif
}
return fun_default_unary;
}
/**
* Initialize an element according to the type of iterator pointed data.
*/
void* _iterator_allocate_init_elem(iterator_t it_iter)
{
void* pv_value = NULL;
assert(_iterator_is_valid(it_iter));
switch (it_iter._t_containertype) {
case _VECTOR_CONTAINER:
pv_value = _alloc_allocate(&((vector_t*)it_iter._pt_container)->_t_allocator,
((vector_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
_vector_init_elem_auxiliary((vector_t*)it_iter._pt_container, pv_value);
break;
case _DEQUE_CONTAINER:
pv_value = _alloc_allocate(&((deque_t*)it_iter._pt_container)->_t_allocator,
((deque_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
_deque_init_elem_auxiliary((deque_t*)it_iter._pt_container, pv_value);
break;
case _BASIC_STRING_CONTAINER:
pv_value = _alloc_allocate(&((basic_string_t*)it_iter._pt_container)->_vec_base._t_allocator,
((basic_string_t*)it_iter._pt_container)->_vec_base._t_typeinfo._pt_type->_t_typesize, 1);
_basic_string_init_elem_auxiliary((basic_string_t*)it_iter._pt_container, pv_value);
break;
case _LIST_CONTAINER:
pv_value = _alloc_allocate(&((list_t*)it_iter._pt_container)->_t_allocator,
((list_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
_list_init_elem_auxiliary((list_t*)it_iter._pt_container, pv_value);
break;
case _SLIST_CONTAINER:
pv_value = _alloc_allocate(&((slist_t*)it_iter._pt_container)->_t_allocator,
((slist_t*)it_iter._pt_container)->_t_typeinfo._pt_type->_t_typesize, 1);
_slist_init_elem_auxiliary((slist_t*)it_iter._pt_container, pv_value);
break;
case _SET_CONTAINER:
pv_value = _alloc_allocate(&((set_t*)it_iter._pt_container)->_t_tree._t_allocator,
((set_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
_set_init_elem_auxiliary((set_t*)it_iter._pt_container, pv_value);
break;
case _MULTISET_CONTAINER:
pv_value = _alloc_allocate(&((multiset_t*)it_iter._pt_container)->_t_tree._t_allocator,
((set_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
_multiset_init_elem_auxiliary((multiset_t*)it_iter._pt_container, pv_value);
break;
case _MAP_CONTAINER:
pv_value = _alloc_allocate(&((map_t*)it_iter._pt_container)->_t_tree._t_allocator,
((map_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
_map_init_elem_auxiliary((map_t*)it_iter._pt_container, pv_value);
break;
case _MULTIMAP_CONTAINER:
pv_value = _alloc_allocate(&((multimap_t*)it_iter._pt_container)->_t_tree._t_allocator,
((multimap_t*)it_iter._pt_container)->_t_tree._t_typeinfo._pt_type->_t_typesize, 1);
_multimap_init_elem_auxiliary((multimap_t*)it_iter._pt_container, pv_value);
break;
case _HASH_SET_CONTAINER:
pv_value = _alloc_allocate(&((hash_set_t*)it_iter._pt_container)->_t_hashtable._t_allocator,
((hash_set_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
_hash_set_init_elem_auxiliary((hash_set_t*)it_iter._pt_container, pv_value);
break;
case _HASH_MULTISET_CONTAINER:
pv_value = _alloc_allocate(&((hash_multiset_t*)it_iter._pt_container)->_t_hashtable._t_allocator,
((hash_multiset_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
_hash_multiset_init_elem_auxiliary((hash_multiset_t*)it_iter._pt_container, pv_value);
break;
case _HASH_MAP_CONTAINER:
pv_value = _alloc_allocate(&((hash_map_t*)it_iter._pt_container)->_t_hashtable._t_allocator,
((hash_map_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
_hash_map_init_elem_auxiliary((hash_map_t*)it_iter._pt_container, pv_value);
break;
case _HASH_MULTIMAP_CONTAINER:
pv_value = _alloc_allocate(&((hash_multimap_t*)it_iter._pt_container)->_t_hashtable._t_allocator,
((hash_multimap_t*)it_iter._pt_container)->_t_hashtable._t_typeinfo._pt_type->_t_typesize, 1);
_hash_multimap_init_elem_auxiliary((hash_multimap_t*)it_iter._pt_container, pv_value);
break;
default:
assert(false);
pv_value = NULL;
break;
}
return pv_value;
}
