Vector from_yaml(type_t<Vector>, const YAML::Node& value)
{
if (!value.IsSequence())
throw deserialize_error{"type must be a sequence but is " +
yaml_type_name(value)};
Vector ret{};
vector_reserve(ret, value.size(), has_reserve<Vector>{});
for (const auto& item : value)
{
try
{
ret.push_back(yaml::deserialize<typename Vector::value_type>(item));
}
catch (deserialize_error& ex)
{
std::string msg = "error when deserializing element " +
std::to_string(ret.size());
ex.add(msg.c_str());
throw;
}
}
return ret;
}
/*
* 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);
}
}
bool vector_resize(struct vector *v, size_t count)
{
if (count < v->count) {
if (v->destruct) {
int i;
uint8 *iter = v->data;
for (i=count, iter+=count*v->element_size; i<v->count; ++i, iter+=v->element_size) {
v->destruct(iter);
}
}
v->count = count;
return true;
}
else if (count > v->count) {
if (count <= v->allocated_count) {
v->count = count;
return true;
}
else {
v->count = count;
return vector_reserve(v, count);
}
}
return true;
}
void vector_init(struct vector* vector, int element_size)
{
vector->element_size = element_size;
vector->size = 0;
vector->capacity = 0;
vector->memory = NULL;
vector_reserve(vector, 1);
}
static bool _vector_grow(vector_t *v, vector_size_t size)
{
if (v) {
v->size += size;
return vector_reserve(v, v->size);
}
return false;
}
int vector_add(struct vector *vec, void *item)
{
int rc = VECE_OK;
if (VECE_OK == (rc = vector_reserve(vec, vec->count + 1))) {
vec->mem[vec->count++] = item;
}
return rc;
}
/**
* 初始化一个动态数组
* @param v 动态数组
* @param len 单个数组元素的长度
* @param capacity 动态数组的元素数量
* @return 初始化成功与否
*/
bool vector_init(vector_t *v, vector_size_t len, vector_size_t capacity)
{
if (v) {
v->len = len;
v->size = 0;
v->capacity = 0;
v->data = NULL;
return vector_reserve(v, capacity);
}
return false;
}
/**
* 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);
}
}
unsigned int vector_add_range(struct vector* vector, void* element, unsigned int num)
{
while(vector->size+num >= vector->capacity)
{
vector_reserve(vector, vector->capacity*2);
}
char* ptr = vector->memory + (vector->size * vector->element_size);
memcpy(ptr, element, vector->element_size * num);
vector->size += num;
return vector->size - 1;
}
/* ------------------------------------------------------------------------- */
void
vector_resize( Vector *self,
const size_t size )
{
assert( self );
if( size > self->capacity)
{
vector_reserve( self, size );
self->size = self->capacity;
}
else
{
self->size = size;
}
}
// -------------------------------------------------- vector_push_back_data ---
void
vector_push_back_data( vector_t *self,
const void * data,
const size_t count )
{
assert( self );
assert( data );
assert( count );
if( self->capacity < (self->size+count) )
{
vector_reserve(self, self->size+count);
}
memmove( (char *)(self->items) + self->size * self->item_size, data,
count*self->item_size );
self->size += count;
}
void test_vector_reserve(void) {
vector* v = vector_new();
printf("vector size = %lu\n", vector_size(v));
printf("vector capacity = %lu\n", vector_capacity(v));
vector_reserve(v, 50);
for(int i = 0; i < 100; ++i) {
int* data = malloc(sizeof(int));
*data = i;
vector_push_back(v, data);
}
printf("vector size = %lu\n", vector_size(v));
printf("vector capacity = %lu\n", vector_capacity(v));
vector_free(v, NULL);
}
/**
* Add specificed element from variable argument list at the end of vector container.
*/
void _vector_push_back_varg(vector_t* pvec_vector, va_list val_elemlist)
{
_byte_t* pby_last = NULL;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/* if the remain capacity is less then the element count */
if (vector_capacity(pvec_vector) == vector_size(pvec_vector)) {
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), 1));
}
/* initialize the last element */
pby_last = pvec_vector->_pby_finish;
assert(pby_last != NULL);
pvec_vector->_pby_finish += _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_auxiliary(pvec_vector, pby_last);
/* copy value from varg */
_type_get_varg_value(&pvec_vector->_t_typeinfo, val_elemlist, pby_last);
}
// ---------------------------------------------------------- vector_insert ---
void
vector_insert( vector_t *self,
const size_t index,
const void *item )
{
assert( self );
assert( index <= self->size);
if( self->capacity <= self->size )
{
vector_reserve(self, 2 * self->capacity );
}
if( index < self->size )
{
memmove( (char *)(self->items) + (index + 1) * self->item_size,
(char *)(self->items) + (index + 0) * self->item_size,
(self->size - index) * self->item_size);
}
self->size++;
vector_set( self, index, item );
}
// ----------------------------------------------------- vector_insert_data ---
void
vector_insert_data( vector_t *self,
const size_t index,
const void * data,
const size_t count )
{
assert( self );
assert( index < self->size );
assert( data );
assert( count );
if( self->capacity < (self->size+count) )
{
vector_reserve(self, self->size+count);
}
memmove( (char *)(self->items) + (index + count ) * self->item_size,
(char *)(self->items) + (index ) * self->item_size,
count*self->item_size );
memmove( (char *)(self->items) + index * self->item_size, data,
count*self->item_size );
self->size += count;
}
/**
* Insert multiple copys of element befor specificed position, the element is from variable argument list.
*/
vector_iterator_t _vector_insert_n_varg(vector_t* pvec_vector, vector_iterator_t it_pos, size_t t_count, va_list val_elemlist)
{
void* pv_varg = NULL;
bool_t b_result = false;
/* test the vector and iterator is valid */
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_pos));
if (t_count > 0) {
size_t i = 0;
_byte_t* pby_oldfinish = NULL;
_byte_t* pby_pos = NULL; /* for initialize elments and insert elements */
_byte_t* pby_destpos = NULL;
/* if the remain capacity is less then the element count */
if (vector_size(pvec_vector) + t_count > vector_capacity(pvec_vector)) {
size_t t_insertpos = iterator_distance(vector_begin(pvec_vector), it_pos);
/* reserve the new size */
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), t_count));
it_pos = iterator_next_n(vector_begin(pvec_vector), t_insertpos);
}
/* insert the element counts of element to the position */
/*
* move the elements from pos to the finish of vector to the
* memory that after the pos element count.
* +-----------------------------------------+
* | | | |
* +-----------------------------------------+
* ^ ^ ^
* | | |
* start it_pos finish
* _t_count__
* / \
* +-----------------------------------------+
* | | |new element| |
* +-----------------------------------------+
* ^ ^ ^ ^
* | | | |
* start it_pos pby_oldfinish finish
*/
/* initialize new elements */
pby_oldfinish = pvec_vector->_pby_finish;
assert(pby_oldfinish != NULL);
pvec_vector->_pby_finish += t_count * _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_range_auxiliary(pvec_vector, pby_oldfinish, pvec_vector->_pby_finish);
/* move element from old finish to new finish */
for (pby_pos = pby_oldfinish - _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos = pvec_vector->_pby_finish - _GET_VECTOR_TYPE_SIZE(pvec_vector);
pby_pos >= _VECTOR_ITERATOR_COREPOS(it_pos);
pby_pos -= _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos -= _GET_VECTOR_TYPE_SIZE(pvec_vector)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(pby_destpos, pby_pos, &b_result);
assert(b_result);
}
/* 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 value for varg */
for (i = 0; i < t_count; ++i) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_pos) + i * _GET_VECTOR_TYPE_SIZE(pvec_vector), 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);
}
return it_pos;
}
void vector_assign(struct vector* vector, void* memory, unsigned int size)
{
vector_reserve(vector, size);
memcpy(vector->memory, memory, size);
vector->size = size;
}
int t_vector()
{
c_vector vt;
__c_vector(&vt, int_comparer);
printf("1.test create vector\n");
create_with_push_back(&vt);
print_vector(&vt);
reverse_print_vector(&vt);
clear_vector(&vt);
printf("\n\n2.test vector assign\n");
create_with_push_back(&vt);
vector_assign(&vt);
clear_vector(&vt);
printf("\n\n3.test erase vector\n");
erase_vector();
printf("\n\n4.test reserve vector\n");
create_with_push_back(&vt);
vector_reserve(&vt);
clear_vector(&vt);
printf("\n\n5.test front back\n");
create_with_push_back(&vt);
vector_front_back(&vt);
clear_vector(&vt);
printf("\n\n6.test swap\n");
create_with_push_back(&vt);
vector_swap(&vt);
clear_vector(&vt);
printf("\n\n7.test insert\n");
vector_insert(&vt);
clear_vector(&vt);
printf("\n\n8.test insert2\n");
create_with_push_back(&vt);
vector_insert2(&vt);
clear_vector(&vt);
printf("\n\n9.test fill insert\n");
create_with_push_back(&vt);
vector_fill_insert(&vt);
clear_vector(&vt);
printf("\n\n10.test resize\n");
create_with_push_back(&vt);
vector_resize(&vt);
clear_vector(&vt);
printf("\n\n11.test equal\n");
create_with_push_back(&vt);
vector_equal(&vt);
clear_vector(&vt);
printf("\n\n12.test less\n");
create_with_push_back(&vt);
vector_less(&vt);
clear_vector(&vt);
__c_rotcev(&vt);
printf("\n\nfinish testing vector!\n");
return 0;
}
/**
* Insert a range of elements into vector at a specificed position.
*/
void vector_insert_range(vector_t* pvec_vector, vector_iterator_t it_pos, vector_iterator_t it_begin, vector_iterator_t it_end)
{
size_t t_count = 0; /* the element count */
bool_t b_result = false;
vector_iterator_t it_first;
vector_iterator_t it_second;
_byte_t* pby_oldfinish = NULL;
_byte_t* pby_pos = NULL;
_byte_t* pby_destpos = NULL;
/* test the vector and iterator is valid */
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(_vector_iterator_belong_to_vector(pvec_vector, it_pos));
/*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));
t_count = iterator_distance(it_begin, it_end);
if(t_count > 0)
{
/* if the remain capacity is less then the element count */
if(vector_size(pvec_vector) + t_count > vector_capacity(pvec_vector))
{
size_t t_distance = _VECTOR_ITERATOR_COREPOS(it_pos) - pvec_vector->_pby_start;
/* reserve the new size */
vector_reserve(pvec_vector, _vector_calculate_new_capacity(vector_size(pvec_vector), t_count));
_VECTOR_ITERATOR_COREPOS(it_pos) = pvec_vector->_pby_start + t_distance;
}
/* initialize new elements */
pby_oldfinish = pvec_vector->_pby_finish;
assert(pby_oldfinish != NULL);
pvec_vector->_pby_finish += t_count * _GET_VECTOR_TYPE_SIZE(pvec_vector);
_vector_init_elem_range_auxiliary(pvec_vector, pby_oldfinish, pvec_vector->_pby_finish);
/* move element from old finish to new finish */
for(pby_pos = pby_oldfinish - _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos = pvec_vector->_pby_finish - _GET_VECTOR_TYPE_SIZE(pvec_vector);
pby_pos >= _VECTOR_ITERATOR_COREPOS(it_pos);
pby_pos -= _GET_VECTOR_TYPE_SIZE(pvec_vector),
pby_destpos -= _GET_VECTOR_TYPE_SIZE(pvec_vector))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(pby_destpos, pby_pos, &b_result);
assert(b_result);
}
/* insert element counts copys to the pos */
for(it_first = it_pos, it_second = it_begin;
!iterator_equal(it_second, it_end);
it_first = iterator_next(it_first), it_second = iterator_next(it_second))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_result);
assert(b_result);
}
assert(_VECTOR_ITERATOR_COREPOS(it_first) == _VECTOR_ITERATOR_COREPOS(it_pos) +
(_VECTOR_ITERATOR_COREPOS(it_end) - _VECTOR_ITERATOR_COREPOS(it_begin)));
}
}
static bool vector_grow(struct vector *v)
{
return vector_reserve(v, v->count*2+1);
}
void vector_destroy(struct vector *v)
{
vector_resize(v, 0);
vector_reserve(v, 0);
}
