/**
* 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));
}
/*
* 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);
}
}
// ----------------------------------------------------------- vector_erase ---
void
vector_erase( vector_t *self,
const size_t index )
{
assert( self );
assert( index < self->size );
vector_erase_range( self, index, index+1 );
}
/**
* 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));
}
// ----------------------------------------------------------------------------
void
vertex_buffer_erase_indices( vertex_buffer_t *self,
const size_t first,
const size_t last )
{
assert( self );
assert( self->indices );
assert( first < self->indices->size );
assert( (last) <= self->indices->size );
self->state |= DIRTY;
vector_erase_range( self->indices, first, last );
}
/**
* 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);
}
}
// ----------------------------------------------------------------------------
void
vertex_buffer_erase_vertices( vertex_buffer_t *self,
const size_t first,
const size_t last )
{
size_t i;
assert( self );
assert( self->vertices );
assert( first < self->vertices->size );
assert( (first+last) <= self->vertices->size );
assert( last > first );
self->state |= DIRTY;
for( i=0; i<self->indices->size; ++i )
{
if( *(GLuint *)(vector_get( self->indices, i )) > first )
{
*(GLuint *)(vector_get( self->indices, i )) -= (last-first);
}
}
vector_erase_range( self->vertices, first, last );
}
/**
* 删除动态数组中的指定元素
* @param v 动态数组
* @param position 位置
* @return 删除成功与否
*/
bool vector_erase(vector_t *v, vector_size_t position)
{
return vector_erase_range(v, position, position + 1);
}
void vector_erase(struct vector* vector, unsigned int index)
{
assert(index < vector->size);
vector_erase_range(vector, index, 1);
}
