/**
* Return an iterator that addresses the first element in the hashtable.
*/
_hashtable_iterator_t _hashtable_begin(const _hashtable_t* cpt_hashtable)
{
vector_iterator_t it_bucket;
_hashtable_iterator_t it_iter = _create_hashtable_iterator();
assert(cpt_hashtable != NULL);
assert(_hashtable_is_inited(cpt_hashtable));
for(it_bucket = vector_begin(&cpt_hashtable->_vec_bucket);
!iterator_equal(it_bucket, vector_end(&cpt_hashtable->_vec_bucket));
it_bucket = iterator_next(it_bucket))
{
_GET_HASHTABLE_BUCKETPOS(it_iter) = _GET_VECTOR_COREPOS(it_bucket);
if(*(_hashnode_t**)_GET_HASHTABLE_BUCKETPOS(it_iter) != NULL)
{
_GET_HASHTABLE_COREPOS(it_iter) = (_byte_t*)*(_hashnode_t**)_GET_HASHTABLE_BUCKETPOS(it_iter);
break;
}
}
if(iterator_equal(it_bucket, vector_end(&cpt_hashtable->_vec_bucket)))
{
assert(_GET_HASHTABLE_COREPOS(it_iter) == NULL);
_GET_HASHTABLE_BUCKETPOS(it_iter) = _GET_VECTOR_COREPOS(it_bucket);
}
_GET_HASHTABLE_POINTER(it_iter) = (_hashtable_t*)cpt_hashtable;
return it_iter;
}
/**
* Assign vector element with an exist vector container range.
*/
void vector_assign_range(vector_t* pvec_vector, vector_iterator_t it_begin, vector_iterator_t it_end)
{
iterator_t it_dest;
iterator_t it_src;
bool_t b_result = false;
/* assign the two iterator is as the same type as pvec_vector */
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_begin));*/
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_end));*/
assert(_vector_same_vector_iterator_type(pvec_vector, it_begin));
assert(_vector_same_vector_iterator_type(pvec_vector, it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
/* copy value from range [it_begin, it_end) for each element */
vector_resize(pvec_vector, iterator_distance(it_begin, it_end));
for(it_dest = vector_begin(pvec_vector), it_src = it_begin;
!iterator_equal(it_dest, vector_end(pvec_vector)) && !iterator_equal(it_src, it_end);
it_dest = iterator_next(it_dest), it_src = iterator_next(it_src))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_dest), _VECTOR_ITERATOR_COREPOS(it_src), &b_result);
assert(b_result);
}
assert(iterator_equal(it_dest, vector_end(pvec_vector)) && iterator_equal(it_src, it_end));
}
/**
* Initialize vector container with an exist vector range.
*/
void vector_init_copy_range(vector_t* pvec_dest, vector_iterator_t it_begin, vector_iterator_t it_end)
{
vector_iterator_t it_dest;
vector_iterator_t it_src;
bool_t b_result = false;
assert(pvec_dest != NULL);
assert(_vector_is_created(pvec_dest));
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_begin), it_begin));
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_end), it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
assert(_vector_same_vector_iterator_type(pvec_dest, it_begin));
assert(_vector_same_vector_iterator_type(pvec_dest, it_end));
/* initialize all elements with default value */
vector_init_n(pvec_dest, iterator_distance(it_begin, it_end));
/* copy values for range */
for(it_dest = vector_begin(pvec_dest), it_src = it_begin;
!iterator_equal(it_dest, vector_end(pvec_dest)) && !iterator_equal(it_src, it_end);
it_dest = iterator_next(it_dest), it_src = iterator_next(it_src))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_dest);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_dest)(_VECTOR_ITERATOR_COREPOS(it_dest), _VECTOR_ITERATOR_COREPOS(it_src), &b_result);
assert(b_result);
}
assert(iterator_equal(it_dest, vector_end(pvec_dest)) && iterator_equal(it_src, it_end));
}
void test_long() {
struct vector* v = vector_new(0, sizeof(long));
long n=10;
long i=0;
for (i=0; i<n; i++) {
vector_push(v, &i);
}
long* iter = vector_front(v);
long* end = vector_end(v);
i=0;
while (iter != end) {
assert(i == *iter);
iter++;
i++;
}
long* lptr = vector_get(v,3);
assert(3 == *lptr);
lptr = vector_pop(v);
assert((n-1) == *lptr);
v=vector_delete(v);
assert(v==NULL);
}
/*
* Specifies a new size of a vector.
*/
void vector_resize(vector_t* pvec_vector, size_t t_resize)
{
vector_iterator_t it_cutpos; /* the cut position */
size_t t_expsize = 0;
_byte_t* pby_oldfinish = NULL;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
if(t_resize == vector_size(pvec_vector))
{
return;
}
else if(t_resize < vector_size(pvec_vector))
{
it_cutpos = vector_begin(pvec_vector);
it_cutpos = iterator_next_n(it_cutpos, t_resize);
vector_erase_range(pvec_vector, it_cutpos, vector_end(pvec_vector));
}
else
{
t_expsize = t_resize - vector_size(pvec_vector);
if(t_resize > vector_capacity(pvec_vector))
{
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), t_expsize));
}
/* initialize new elements */
pby_oldfinish = pvec_vector->_pby_finish;
pvec_vector->_pby_finish += t_expsize * _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_range_auxiliary(pvec_vector, pby_oldfinish, pvec_vector->_pby_finish);
}
}
/**
* Test the first vector is less than the second vector.
*/
bool_t vector_less(const vector_t* cpvec_first, const vector_t* cpvec_second)
{
bool_t b_result = false;
vector_iterator_t it_first;
vector_iterator_t it_second;
assert(cpvec_first != NULL);
assert(cpvec_second != NULL);
assert(_vector_is_inited(cpvec_first));
assert(_vector_is_inited(cpvec_second));
assert(_vector_same_type(cpvec_first, cpvec_second));
for(it_first = vector_begin(cpvec_first), it_second = vector_begin(cpvec_second);
!iterator_equal(it_first, vector_end(cpvec_first)) && !iterator_equal(it_second, vector_end(cpvec_second));
it_first = iterator_next(it_first), it_second = iterator_next(it_second))
{
b_result = _GET_VECTOR_TYPE_SIZE(cpvec_first);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_result);
/* if any element in first vector are less then the second return true */
if(b_result)
{
return true;
}
b_result = _GET_VECTOR_TYPE_SIZE(cpvec_first);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_second), _VECTOR_ITERATOR_COREPOS(it_first), &b_result);
/* if any element in first vector are greater then the second return false */
if(b_result)
{
return false;
}
}
/* if the first n elements in two vector are equal then compare the vector size */
return vector_size(cpvec_first) < vector_size(cpvec_second) ? true : false;
}
/**
* Initialize vector with variable argument list of specified element.
*/
void _vector_init_elem_varg(vector_t* pvec_vector, size_t t_count, va_list val_elemlist)
{
void* pv_varg = NULL;
bool_t b_result = false;
vector_iterator_t it_iter;
assert(pvec_vector != NULL);
assert(_vector_is_created(pvec_vector));
/* initialize vector_t */
vector_init_n(pvec_vector, t_count);
if(t_count > 0)
{
/* get varg value only once */
pv_varg = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
assert(pv_varg != NULL);
_vector_get_varg_value_auxiliary(pvec_vector, val_elemlist, pv_varg);
/* copy varg value to each element */
for(it_iter = vector_begin(pvec_vector);
!iterator_equal(it_iter, vector_end(pvec_vector));
it_iter = iterator_next(it_iter))
{
/* copy from varg */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg value and free memory */
_vector_destroy_varg_value_auxiliary(pvec_vector, pv_varg);
_alloc_deallocate(&pvec_vector->_t_allocator, pv_varg, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
}
}
void
fixed_gap_arena_insert(FixedGapArena *arena,
memi offset,
const ch8 *data,
memi size)
{
// TODO: In case we can take ownership of data, we can just wrap it with gap buffers and be done.
// TODO: In case we cannot take ownership of data, but the data is persistent, we can wrap it with copy-on-write gap buffers.
// TODO: Remove the checks.
if (size == 0) {
return;
}
hale_assert(offset <= arena->size);
hale_assert_debug(vector_count(arena->buffers));
Buf *it0 = find_buf_GTE(arena,
&offset,
vector_begin(&arena->buffers),
vector_end(&arena->buffers));
// Move these to tests.
hale_assert_requirement(it0);
// hale_assert(buf_length(it) != 0);
hale_assert(buf_length(it0) >= offset);
if (buf_available(it0) >= size) {
buf_insert(it0, offset, data, size);
} else {
insert_non_crit_branch(arena, offset, data, size, it0);
}
arena->size += size;
}
/**
* Destroy vector container auxiliary function.
*/
void _vector_destroy_auxiliary(vector_t* pvec_vector)
{
vector_iterator_t it_iter;
vector_iterator_t it_begin;
vector_iterator_t it_end;
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector) || _vector_is_created(pvec_vector));
/* destroy all elements */
it_begin = vector_begin(pvec_vector);
it_end = vector_end(pvec_vector);
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), &b_result);
assert(b_result);
}
/* free vector memory */
if (pvec_vector->_pby_start != NULL) {
_alloc_deallocate(&pvec_vector->_t_allocator, pvec_vector->_pby_start, _GET_VECTOR_TYPE_SIZE(pvec_vector),
(pvec_vector->_pby_endofstorage - pvec_vector->_pby_start) / _GET_VECTOR_TYPE_SIZE(pvec_vector));
}
_alloc_destroy(&pvec_vector->_t_allocator);
pvec_vector->_pby_start = NULL;
pvec_vector->_pby_finish = NULL;
pvec_vector->_pby_endofstorage = NULL;
}
/**
* Get the pointer that point to the iterator reference data, but ignore char*.
*/
const void* _vector_iterator_get_pointer_ignore_cstr(vector_iterator_t it_iter)
{
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_iter), it_iter));
assert(!_vector_iterator_equal(it_iter, vector_end(_VECTOR_ITERATOR_CONTAINER(it_iter))));
return _VECTOR_ITERATOR_COREPOS(it_iter);
}
/**
* Assign vector with variable argument list of specificed element.
*/
void _vector_assign_elem_varg(vector_t* pvec_vector, size_t t_count, va_list val_elemlist)
{
iterator_t it_iter;
iterator_t it_begin;
iterator_t it_end;
bool_t b_result = false;
void* pv_varg = NULL;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/* get value from varg */
pv_varg = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
assert(pv_varg != NULL);
_vector_get_varg_value_auxiliary(pvec_vector, val_elemlist, pv_varg);
/* copy value from varg for each element */
vector_resize(pvec_vector, t_count);
it_begin = vector_begin(pvec_vector);
it_end = vector_end(pvec_vector);
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg and free memory */
_vector_destroy_varg_value_auxiliary(pvec_vector, pv_varg);
_alloc_deallocate(&pvec_vector->_t_allocator, pv_varg, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
}
void test_sort() {
struct vector* v = vector_new(7, sizeof(struct test));
struct test* t = NULL;
t = vector_get(v,0);
t->id = 4;
t = vector_get(v,1);
t->id = 1;
t = vector_get(v,2);
t->id = 2;
t = vector_get(v,3);
t->id = 0;
t = vector_get(v,4);
t->id = 3;
t = vector_get(v,5);
t->id = 6;
t = vector_get(v,6);
t->id = 5;
vector_sort(v, &compare_test);
size_t i=0;
struct test* iter = vector_front(v);
struct test* end = vector_end(v);
while (iter != end) {
assert(iter->id == i);
iter++;
i++;
}
}
/**
* Erases the elements of vector.
*/
void vector_clear(vector_t* pvec_vector)
{
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
vector_erase_range(pvec_vector, vector_begin(pvec_vector), vector_end(pvec_vector));
}
/**
* Test the two vectors are equal.
*/
bool_t vector_equal(const vector_t* cpvec_first, const vector_t* cpvec_second)
{
vector_iterator_t it_first;
vector_iterator_t it_second;
bool_t b_less = false;
bool_t b_greater = false;
assert(cpvec_first != NULL);
assert(cpvec_second != NULL);
assert(_vector_is_inited(cpvec_first));
assert(_vector_is_inited(cpvec_second));
/* same vector container */
if(cpvec_first == cpvec_second)
{
return true;
}
/* the element type is equal */
if(!_vector_same_type(cpvec_first, cpvec_second))
{
return false;
}
/* the element count is equal */
if(vector_size(cpvec_first) != vector_size(cpvec_second))
{
return false;
}
/* each element is equal */
for(it_first = vector_begin(cpvec_first), it_second = vector_begin(cpvec_second);
!iterator_equal(it_first, vector_end(cpvec_first)) && !iterator_equal(it_second, vector_end(cpvec_second));
it_first = iterator_next(it_first), it_second = iterator_next(it_second))
{
b_less = _GET_VECTOR_TYPE_SIZE(cpvec_first);
b_greater = _GET_VECTOR_TYPE_SIZE(cpvec_second);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_less);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_second)(_VECTOR_ITERATOR_COREPOS(it_second), _VECTOR_ITERATOR_COREPOS(it_first), &b_greater);
if(b_less || b_greater)
{
return false;
}
}
assert(iterator_equal(it_first, vector_end(cpvec_first)) &&
iterator_equal(it_second, vector_end(cpvec_second)));
return true;
}
void priority_queue_pop(priority_queue_t* pt_pqueue)
{
assert(pt_pqueue != NULL);
if(pt_pqueue->_t_binary_op == NULL)
{
algo_pop_heap(
vector_begin(&pt_pqueue->_t_vector), vector_end(&pt_pqueue->_t_vector));
}
else
{
algo_pop_heap_if(
vector_begin(&pt_pqueue->_t_vector), vector_end(&pt_pqueue->_t_vector),
pt_pqueue->_t_binary_op);
}
vector_pop_back(&pt_pqueue->_t_vector);
}
/**
* Removes an element in vector from specificed position.
*/
vector_iterator_t vector_erase(vector_t* pvec_vector, vector_iterator_t it_pos)
{
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_pos));
assert(!iterator_equal(it_pos, vector_end(pvec_vector)));
return vector_erase_range(pvec_vector, it_pos, iterator_next(it_pos));
}
/**
* Initialize vector container with an exist vector container.
*/
void vector_init_copy(vector_t* pvec_dest, const vector_t* cpvec_src)
{
assert(pvec_dest != NULL);
assert(cpvec_src != NULL);
assert(_vector_is_created(pvec_dest));
assert(_vector_is_inited(cpvec_src));
assert(_vector_same_type(pvec_dest, cpvec_src));
vector_init_copy_range(pvec_dest, vector_begin(cpvec_src), vector_end(cpvec_src));
}
/**
* Return iterator reference previous element.
*/
_hashtable_iterator_t _hashtable_iterator_prev(_hashtable_iterator_t it_iter)
{
vector_iterator_t it_bucket;
_hashnode_t* pt_node = NULL;
_hashnode_t* pt_prevnode = NULL;
assert(_hashtable_iterator_belong_to_hashtable(_HASHTABLE_ITERATOR_HASHTABLE(it_iter), it_iter));
assert(!_hashtable_iterator_equal(it_iter, _hashtable_begin(_HASHTABLE_ITERATOR_HASHTABLE(it_iter))));
/* hashtable end is specifical condition. corepos == NULL and bucketpos is invalid pos */
if(_hashtable_iterator_equal(it_iter, _hashtable_end(_HASHTABLE_ITERATOR_HASHTABLE(it_iter))))
{
it_bucket = iterator_prev(vector_end(&_HASHTABLE_ITERATOR_HASHTABLE(it_iter)->_vec_bucket));
_HASHTABLE_ITERATOR_BUCKETPOS(it_iter) = _VECTOR_ITERATOR_COREPOS(it_bucket);
}
pt_node = (_hashnode_t*)_HASHTABLE_ITERATOR_COREPOS(it_iter);
pt_prevnode = *(_hashnode_t**)_HASHTABLE_ITERATOR_BUCKETPOS(it_iter);
/* current node is first node in current bucket */
if(pt_prevnode == pt_node)
{
it_bucket = vector_begin(&(_HASHTABLE_ITERATOR_HASHTABLE(it_iter)->_vec_bucket));
_VECTOR_ITERATOR_COREPOS(it_bucket) = _HASHTABLE_ITERATOR_BUCKETPOS(it_iter);
for(it_bucket = iterator_prev(it_bucket);
iterator_greater_equal(it_bucket, vector_begin(&(_HASHTABLE_ITERATOR_HASHTABLE(it_iter)->_vec_bucket)));
it_bucket = iterator_prev(it_bucket))
{
pt_node = *(_hashnode_t**)_VECTOR_ITERATOR_COREPOS(it_bucket);
if(pt_node != NULL)
{
/* get the last hashnode */
while(pt_node->_pt_next != NULL)
{
pt_node = pt_node->_pt_next;
}
/* set bucket pos and core pos */
_HASHTABLE_ITERATOR_BUCKETPOS(it_iter) = _VECTOR_ITERATOR_COREPOS(it_bucket);
_HASHTABLE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_node;
break;
}
}
}
else
{
while(pt_prevnode->_pt_next != pt_node)
{
pt_prevnode = pt_prevnode->_pt_next;
}
/* set core pos */
_HASHTABLE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prevnode;
}
return it_iter;
}
//handler para tratar CTRL + C
static void ctrlc_hand(int signo, siginfo_t *info, void *data) {
if (background == 1) {
return;
}
else {
Job job = vector_end(job_list);
if (job)
kill(string_to_int(job->pid), SIGINT);
}
}
/**
* Return iterator reference next element.
*/
_hashtable_iterator_t _hashtable_iterator_next(_hashtable_iterator_t it_iter)
{
vector_iterator_t it_bucket;
_hashnode_t* pt_node = NULL;
assert(_hashtable_iterator_belong_to_hashtable(_HASHTABLE_ITERATOR_HASHTABLE(it_iter), it_iter));
assert(!_hashtable_iterator_equal(it_iter, _hashtable_end(_HASHTABLE_ITERATOR_HASHTABLE(it_iter))));
pt_node = (_hashnode_t*)_HASHTABLE_ITERATOR_COREPOS(it_iter);
assert(pt_node != NULL);
if(pt_node->_pt_next == NULL)
{
/* iterator from current bucket pos to end */
it_bucket = vector_begin(&(_HASHTABLE_ITERATOR_HASHTABLE(it_iter)->_vec_bucket));
_VECTOR_ITERATOR_COREPOS(it_bucket) = _HASHTABLE_ITERATOR_BUCKETPOS(it_iter);
for(it_bucket = iterator_next(it_bucket);
!iterator_equal(it_bucket, vector_end(&(_HASHTABLE_ITERATOR_HASHTABLE(it_iter)->_vec_bucket)));
it_bucket = iterator_next(it_bucket))
{
_HASHTABLE_ITERATOR_BUCKETPOS(it_iter) = _VECTOR_ITERATOR_COREPOS(it_bucket);
if(*(_hashnode_t**)_HASHTABLE_ITERATOR_BUCKETPOS(it_iter) != NULL)
{
_HASHTABLE_ITERATOR_COREPOS(it_iter) = (_byte_t*)(*(_hashnode_t**)_HASHTABLE_ITERATOR_BUCKETPOS(it_iter));
break;
}
}
if(iterator_equal(it_bucket, vector_end(&(_HASHTABLE_ITERATOR_HASHTABLE(it_iter)->_vec_bucket))))
{
assert((_hashnode_t*)_HASHTABLE_ITERATOR_COREPOS(it_iter) == pt_node);
_HASHTABLE_ITERATOR_COREPOS(it_iter) = NULL;
_HASHTABLE_ITERATOR_BUCKETPOS(it_iter) = _VECTOR_ITERATOR_COREPOS(it_bucket);
}
}
else
{
_HASHTABLE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_node->_pt_next;
}
return it_iter;
}
//handler para tratar CTRL + Z
static void ctrlz_hand(int signo, siginfo_t *info, void *data) {
if(background == 0){
vector_reset(job_list);
Job job = (Job) vector_end(job_list);
if(job){
background = 1;
job->status = STOPPED;
kill(-getpid(), SIGTSTP);
}
}
}
/**
* Get the pointer that point to the iterator reference data.
*/
const void* _vector_iterator_get_pointer(vector_iterator_t it_iter)
{
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_iter), it_iter));
assert(!_vector_iterator_equal(it_iter, vector_end(_VECTOR_ITERATOR_CONTAINER(it_iter))));
/* char* */
if (strncmp(_GET_VECTOR_TYPE_BASENAME(_VECTOR_ITERATOR_CONTAINER(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
return string_c_str((string_t*)_VECTOR_ITERATOR_COREPOS(it_iter));
} else {
return _VECTOR_ITERATOR_COREPOS(it_iter);
}
}
void priority_queue_init_copy_range_ex(
priority_queue_t* pt_pqueuedest, random_access_iterator_t t_first,
random_access_iterator_t t_last, binary_function_t t_binary_op)
{
assert(pt_pqueuedest != NULL);
vector_init_copy_range(&pt_pqueuedest->_t_vector, t_first, t_last);
pt_pqueuedest->_t_binary_op = t_binary_op;
if(pt_pqueuedest->_t_binary_op == NULL)
{
algo_make_heap(
vector_begin(&pt_pqueuedest->_t_vector), vector_end(&pt_pqueuedest->_t_vector));
}
else
{
algo_make_heap_if(
vector_begin(&pt_pqueuedest->_t_vector), vector_end(&pt_pqueuedest->_t_vector),
pt_pqueuedest->_t_binary_op);
}
}
/**
* Reset the size of vector elements, and filled element is from variable argument list.
*/
void _vector_resize_elem_varg(vector_t* pvec_vector, size_t t_resize, va_list val_elemlist)
{
vector_iterator_t t_cutpos; /* the cut position */
size_t t_expsize = 0;
size_t i = 0;
void* pv_varg = NULL;
_byte_t* pby_oldfinish = NULL;
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
if(t_resize == vector_size(pvec_vector))
{
return;
}
else if(t_resize < vector_size(pvec_vector))
{
t_cutpos = vector_begin(pvec_vector);
t_cutpos = iterator_next_n(t_cutpos, t_resize);
vector_erase_range(pvec_vector, t_cutpos, vector_end(pvec_vector));
}
else
{
t_expsize = t_resize - vector_size(pvec_vector);
if(t_resize > vector_capacity(pvec_vector))
{
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), t_expsize));
}
/* get varg value only once */
pv_varg = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
assert(pv_varg != NULL);
_vector_get_varg_value_auxiliary(pvec_vector, val_elemlist, pv_varg);
/* initialize new elements */
pby_oldfinish = pvec_vector->_pby_finish;
pvec_vector->_pby_finish += t_expsize * _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_range_auxiliary(pvec_vector, pby_oldfinish, pvec_vector->_pby_finish);
/* copy value from varg to new elements */
for(i = 0; i < t_expsize; ++i)
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(pby_oldfinish + i * _GET_VECTOR_TYPE_SIZE(pvec_vector), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg */
_vector_destroy_varg_value_auxiliary(pvec_vector, pv_varg);
_alloc_deallocate(&pvec_vector->_t_allocator, pv_varg, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
}
}
/**
* Return an iterator that addresses the location succeeding the last element in the hashtable.
*/
_hashtable_iterator_t _hashtable_end(const _hashtable_t* cpt_hashtable)
{
vector_iterator_t it_bucket;
_hashtable_iterator_t it_iter = _create_hashtable_iterator();
assert(cpt_hashtable != NULL);
assert(_hashtable_is_inited(cpt_hashtable));
it_bucket = vector_end(&cpt_hashtable->_vec_bucket);
_GET_HASHTABLE_BUCKETPOS(it_iter) = _GET_VECTOR_COREPOS(it_bucket);
_GET_HASHTABLE_COREPOS(it_iter) = NULL;
_GET_HASHTABLE_POINTER(it_iter) = (_hashtable_t*)cpt_hashtable;
return it_iter;
}
/**
* Test iterator referenced data is within the hashtable.
*/
bool_t _hashtable_iterator_belong_to_hashtable(const _hashtable_t* cpt_hashtable, _hashtable_iterator_t it_iter)
{
vector_iterator_t it_bucket;
vector_iterator_t it_begin;
vector_iterator_t it_end;
assert(cpt_hashtable != NULL);
assert(_hashtable_is_inited(cpt_hashtable));
assert(_HASHTABLE_ITERATOR_BUCKETPOS(it_iter) != NULL);
assert(_HASHTABLE_ITERATOR_HASHTABLE(it_iter) == cpt_hashtable);
/* check for the end node */
it_bucket = vector_end(&cpt_hashtable->_vec_bucket);
if (_VECTOR_ITERATOR_COREPOS(it_bucket) == _HASHTABLE_ITERATOR_BUCKETPOS(it_iter) &&
_HASHTABLE_ITERATOR_COREPOS(it_iter) == NULL) {
return true;
} else {
_hashnode_t* pt_node = NULL;
it_begin = vector_begin(&cpt_hashtable->_vec_bucket);
it_end = vector_end(&cpt_hashtable->_vec_bucket);
for (it_bucket = it_begin; !iterator_equal(it_bucket, it_end); it_bucket = iterator_next(it_bucket)) {
if (_HASHTABLE_ITERATOR_BUCKETPOS(it_iter) == _VECTOR_ITERATOR_COREPOS(it_bucket)) {
pt_node = *(_hashnode_t**)_VECTOR_ITERATOR_COREPOS(it_bucket);
while (pt_node != NULL) {
if (pt_node == (_hashnode_t*)_HASHTABLE_ITERATOR_COREPOS(it_iter)) {
return true;
}
pt_node = pt_node->_pt_next;
}
}
}
return false;
}
}
/**
* Assign vector element with an exist vector container.
*/
void vector_assign(vector_t* pvec_dest, const vector_t* cpvec_src)
{
assert(pvec_dest != NULL);
assert(cpvec_src != NULL);
assert(_vector_is_inited(pvec_dest));
assert(_vector_is_inited(cpvec_src));
assert(_vector_same_type(pvec_dest, cpvec_src));
if(vector_equal(pvec_dest, cpvec_src))
{
return;
}
vector_assign_range(pvec_dest, vector_begin(cpvec_src), vector_end(cpvec_src));
}
/**
* Set iterator reference data.
*/
void _vector_iterator_set_value(vector_iterator_t it_iter, const void* cpv_value)
{
bool_t b_result = false;
assert(cpv_value != NULL);
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_iter), it_iter));
assert(!_vector_iterator_equal(it_iter, vector_end(_VECTOR_ITERATOR_CONTAINER(it_iter))));
/* char* */
if (strncmp(_GET_VECTOR_TYPE_BASENAME(_VECTOR_ITERATOR_CONTAINER(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
string_assign_cstr((string_t*)_VECTOR_ITERATOR_COREPOS(it_iter), (char*)cpv_value);
} else {
b_result = _GET_VECTOR_TYPE_SIZE(_VECTOR_ITERATOR_CONTAINER(it_iter));
_GET_VECTOR_TYPE_COPY_FUNCTION(_VECTOR_ITERATOR_CONTAINER(it_iter))(_VECTOR_ITERATOR_COREPOS(it_iter), cpv_value, &b_result);
assert(b_result);
}
}
void test_ptr() {
struct vector* v = vector_new(0, sizeof(struct test*));
size_t i=0, n=10;
// note we never own the pointers in the vector! So we must allocat and
// free them separately
struct test* tvec = calloc(n, sizeof(struct test));
for (i=0; i<n; i++) {
struct test *t = &tvec[i];
t->id = i;
t->x = 2*i;
// this copies the pointer to t
vector_push(v, &t);
}
// two different ways to use vector_get for pointers
for (i=0; i<n; i++) {
struct test **t = vector_get(v, i);
assert((*t)->id == i);
assert((*t)->x == 2*i);
}
for (i=0; i<n; i++) {
struct test *t = *(struct test**) vector_get(v, i);
assert(t->id == i);
assert(t->x == 2*i);
}
// iteration
i=0;
struct test **iter = vector_front(v);
struct test **end = vector_end(v);
while (iter != end) {
assert((*iter)->id == i);
iter++;
i++;
}
v=vector_delete(v);
assert(v==NULL);
free(tvec);
}
void test_create_and_access() {
size_t n=10;
struct vector* v = vector_new(n, sizeof(struct test));
assert(v->size == n);
assert(n == vector_size(v));
assert(v->capacity == n);
struct test* iter = vector_front(v);
struct test* end = vector_end(v);
size_t i=0;
while (iter != end) {
iter->id = i;
iter->x = 2*i;
wlog(" id: %d x: %g\n", iter->id, iter->x);
iter++;
i++;
}
iter = vector_front(v);
i=0;
while (iter != end) {
assert(iter->id == i);
assert(iter->x == 2*i);
iter++;
i++;
}
i=7;
struct test t;
t.id = 57;
t.x = -8.2457;
vector_set(v, i, &t);
struct test* el = vector_get(v, i);
assert(el->id == t.id);
assert(el->x == t.x);
v = vector_delete(v);
assert(v == NULL);
}
