Bool Vector_printf(Vector *v, Allocator allocator, char const *format, ...)
{
size_t const speculative_result_length = strlen(format) * 2;
va_list args;
ptrdiff_t printed;
if (!Vector_resize(v, speculative_result_length, allocator))
{
return False;
}
va_start(args, format);
printed = vsnprintf(Vector_data(v), Vector_size(v), format, args);
assert(printed >= 0);
if ((size_t)printed == Vector_size(v))
{
if (!Vector_resize(v, (size_t)printed + 1, allocator))
{
va_end(args);
return False;
}
printed = vsnprintf(Vector_data(v), Vector_size(v), format, args);
assert((size_t)printed == Vector_size(v));
}
Vector_resize_smaller(v, (size_t)printed + 1);
va_end(args);
return True;
}
static void test_vector(void)
{
MemoryManager memory = create_standard_memory_manager();
{
Vector v;
Vector_init(&v);
TEST(Vector_empty(&v));
TEST(Vector_size(&v) == 0);
Vector_free(&v, memory.deallocator);
}
{
Vector v;
Vector_init(&v);
TEST(Vector_reserve(&v, 100, memory.allocator));
TEST(Vector_reserve(&v, 200, memory.allocator));
TEST(Vector_reserve(&v, 50, memory.allocator));
TEST(Vector_reserve(&v, 0, memory.allocator));
Vector_free(&v, memory.deallocator);
}
{
Vector v;
Vector_init(&v);
TEST(Vector_resize(&v, 100, memory.allocator));
TEST(Vector_resize(&v, 200, memory.allocator));
TEST(Vector_resize(&v, 50, memory.allocator));
TEST(Vector_resize(&v, 0, memory.allocator));
Vector_free(&v, memory.deallocator);
}
{
size_t i;
size_t const count = 1000;
Vector v;
Vector_init(&v);
for (i = 0; i < count; ++i)
{
char c = (char)('0' + (i % 10));
ASSERT(Vector_push_back(&v, &c, 1, memory.allocator));
}
for (i = 0; i < count; ++i)
{
char c = (char)('0' + (i % 10));
ASSERT(Vector_data(&v)[i] == c);
}
Vector_free(&v, memory.deallocator);
}
}
Bool Vector_append_binary_file(Vector *v, Allocator v_allocator, FILE *in)
{
size_t const original_size = Vector_size(v);
size_t buffer_size = 8192;
for (;;)
{
size_t const offset_to_read_to = Vector_size(v);
size_t const max_size_t = ~(size_t)0;
size_t resizing = original_size + buffer_size;
size_t read_size;
size_t actually_read;
if (resizing > max_size_t)
{
resizing = max_size_t;
}
if (!Vector_resize(v, resizing, v_allocator))
{
Vector_resize_smaller(v, original_size);
return False;
}
read_size = resizing - offset_to_read_to;
actually_read = fread(Vector_data(v) + offset_to_read_to, 1, read_size, in);
if (actually_read < read_size)
{
Vector_resize_smaller(v, offset_to_read_to + actually_read);
return True;
}
}
}
void
AntiDOS_update(AntiDOS *dos)
{
time_t t = time(0);
assert(dos!=0);
if (t-dos->min_time > ANTIDOS_TIME_BASE) {
bool was_changed = false;
struct Data *i;
dos->min_time = t;
for (i = Vector_begin(&dos->data); i!=Vector_end(&dos->data); ++i) {
if (t - i->access_time>ANTIDOS_TIME_BASE) {
i->ip.s_addr = 0xFFFFFFFF;
was_changed = true;
}
else
dos->min_time = MIN(dos->min_time, i->access_time);
}
if (was_changed) {
Vector_sort(&dos->data, Data_sortCompare);
for (i=Vector_end(&dos->data); i!=Vector_begin(&dos->data);) {
--i;
if (i->ip.s_addr!=0xFFFFFFFF) break;
Vector_popback(&dos->data);
}
Vector_resize(&dos->data);
}
}
}
void
Vector_add(struct Vector *self, const char *name)
{
assert(!self->constant);
Vector_resize(self, self->length+1);
strlcpy(self->base + self->size * self->length, name, self->size);
self->length++;
}
int
Vector_remove(struct Vector *self, const char *name)
{
int i;
assert(!self->constant);
for (i=0; i<self->length; i++)
if (strcasecmp(self->base + self->size * i, name) == 0) {
strlcpy(self->base + self->size * i,
self->base + self->size * (self->length-1), self->size);
self->length--;
Vector_resize(self, self->length);
return 1;
}
return 0;
}
int
Vector_append(Vector v, size_t count, void *values)
{
int ret;
ptrdiff_t new_size;
if (!v || !values)
return -EINVAL;
new_size = v->size + count;
if (new_size > v->capacity)
if ((ret = Vector_resize(v, new_size)))
return ret;
memcpy(Vector_address(v, v->size), values, count * v->unit);
v->size = new_size;
return 0;
}
// Test your vector here
int main() {
Vector* temp = Vector_create(); //create a vector
Vector_append( temp, "a");//1
Vector_append( temp, "b");//2
Vector_append( temp, "c");//3
Vector_append( temp, "d");//4
Vector_append( temp, NULL);//5
Vector_append( temp, "f");//6
Vector_append( temp, "g");//7
Vector_append( temp, NULL);//8
Vector_append( temp, "");//9
Vector_append( temp, "h");//10
Vector_append( temp, "i");//11
Vector_append( temp, NULL);//12
Vector_resize( temp, 20 );
if( Vector_size(temp) != 20 || strcmp( Vector_get( temp, 10 ), "i" ) || Vector_get( temp, 15 ) != NULL )
perror( "something wrong.\n");
//done for append, resize, get, size
Vector_set( temp, 19, "caibi" );
Vector_insert( temp, 20, "niubi" );
Vector_insert( temp, 30, "wori" );
if( Vector_size(temp) != 31 || strcmp( Vector_get( temp, 19 ), "caibi" ) || strcmp( Vector_get( temp, 20 ), "niubi" ) || Vector_get( temp, 15 ) != NULL || strcmp( Vector_get( temp, 30 ), "wori" ) )
perror( "something wrong.\n");
Vector_delete( temp, 11 );
Vector_delete( temp, 27 );
Vector_delete( temp, 1 );
Vector_delete( temp, 18 );
if( Vector_size(temp) != 27 || strcmp( Vector_get( temp, 4 ), "f" ) || strcmp( Vector_get( temp, 26 ), "wori") || Vector_get( temp, 18 ) !=NULL || strcmp( Vector_get( temp, 17 ), "caibi") )
perror( "something wrong.\n");
Vector_destroy( temp );
return 0;
}
int
Vector_set(Vector v, ptrdiff_t index, void *value)
{
int ret;
if (!v || !value)
return -EINVAL;
if (index < -v->size)
return -EINVAL;
if (index >= v->capacity)
if ((ret = Vector_resize(v, index + 1)))
return ret;
memcpy(Vector_address(v, index), value, v->unit);
if (v->size < index + 1) {
memset(Vector_address(v, v->size), 0, (index - v->size) * v->unit);
v->size = index + 1;
}
return 0;
}
