END_TEST START_TEST(test_array_resize) { array_t* array; const size_t capacity1 = 1; const size_t capacity2 = 2; uint32_t value1 = 0xf00fba11; uint32_t value2 = 0xdeadbeef; const size_t element_size = sizeof(typeof(value1)); array = array_create(element_size); array_reserve(array, capacity1); ck_assert_int_eq(array_get_capacity(array), capacity1); ck_assert(array_get(array, typeof(value1)) != NULL); array_at(array, 0, typeof(value1)) = value1; array_reserve(array, capacity2); ck_assert_int_eq(array_get_capacity(array), capacity2); ck_assert_int_eq(array_at(array, 0, typeof(value1)), value1); array_at(array, 1, typeof(value1)) = value2; ck_assert_int_eq(array_at(array, 1, typeof(value1)), value2); array_reserve(array, capacity1); ck_assert_int_eq(array_get_capacity(array), capacity2); ck_assert_int_eq(array_at(array, 0, typeof(value1)), value1); ck_assert_int_eq(array_at(array, 1, typeof(value1)), value2); array_destroy(array); }
// sets errno on error void *array_append(Array *array) { void *item; if (array_reserve(array, array->count + 1) < 0) { return NULL; } ++array->count; if (array->relocatable) { item = array_get(array, array->count - 1); memset(item, 0, array->size); } else { item = calloc(1, array->size); if (item == NULL) { --array->count; errno = ENOMEM; return NULL; } *(void **)(array->bytes + sizeof(void *) * (array->count - 1)) = item; } return item; }
int array_resize(Array *array, int count, FreeFunction function) { int rc; int i; void *item; if (array->count < count) { rc = array_reserve(array, count); if (rc < 0) { return rc; } } else if (array->count > count) { if (function != NULL) { for (i = count; i < array->count; ++i) { item = array_get(array, i); function(item); if (!array->relocatable) { free(item); } } } else if (!array->relocatable) { for (i = count; i < array->count; ++i) { free(array_get(array, i)); } } } array->count = count; return 0; }
void font_init() { array_reserve(s_fontCtx.fonts, 16); s_fontCtx.fontShader = shader_create_fromfiles("font.vert", "font.frag"); s_fontCtx.fontSettingsParam = shader_get_param( s_fontCtx.fontShader, "FontSettings", ShaderParamType_UniformBlock ); vector_t translation = vector_zero(); vector_t scale = vector(1/640.0f, 1/480.0f, 1.0f, 0.f); vector_t rotation = vector_zero(); font_shader_settings_t settings; settings.color = vector(1.0f,1.0f,1.0f,1.0f); settings.transform = create_transform_matrix(translation, scale, rotation); s_fontCtx.fontSettingsBuffer = shader_uniformbuffer_create( s_fontCtx.fontSettingsParam, (void*) &settings ); s_fontCtx.fontState.useBlend = true; s_fontCtx.fontState.srcBlendState = BlendState_SrcAlpha; s_fontCtx.fontState.dstBlendState = BlendState_One; s_fontCtx.fontState.useStencil = false; }
array_t *array_init(array_t *self, size_t object_size, size_t capacity, allocator_t *alloc) { if (alloc == NULL) alloc = g_default_allocator; if (object_size == 0) { s_fatal_error(1, "Invalid object size for array: 0."); return NULL; } else if (!(alloc->malloc && alloc->free)) { s_fatal_error(1, "malloc & free pointers are NULL."); return NULL; } else if (NULL == self) { s_fatal_error(1, "Failed to allocate array."); return NULL; } self->allocator = alloc; self->obj_size = object_size; self->size = 0; self->capacity = 0; self->buf = NULL; if (!array_reserve(self, capacity)) { array_destroy(self); s_fatal_error(1, "Failed to create array with capacity %zu", capacity); return NULL; } return self; }
bool array_resize(array_t *self, size_t size) { if (self == NULL) { s_fatal_error(1, "Cannot resize NULL array."); return false; } if (array_reserve(self, size)) { if (self->buf) { if (size == 0 && self->size != 0) { // simply zero the used portion of the array memset(self->buf, 0, self->size * self->obj_size); } else if (size < self->size) { // zero the portion of the array cut off memset(self->buf + (size * self->obj_size), 0, (self->size - size) * self->obj_size); } } self->size = size; return true; } s_fatal_error(1, "Failed to resize array."); return false; }
int _random_initialize( void ) { if( !_random_mutex ) { int i; _random_mutex = mutex_allocate( "random" ); //Allocate and seed a number of state buffers array_reserve( _random_state, 64 ); array_reserve( _random_available_state, 64 ); for( i = 0; i < 16; ++i ) { unsigned int* buffer = _random_allocate_buffer(); array_push( _random_available_state, buffer ); } } return 0; }
void init_quarks(void) { size_t index; if (quarks) return; quarks = array_new((free_function_t)array_free); array_reserve(quarks, HASH_SIZE); for (index = 0; index < HASH_SIZE; ++index) array_append(quarks, array_new((free_function_t)free)); quarks_index = array_new(NULL); }
static void test_array(void **state) { int ret = 0; array_t(int) arr; array_init(arr); /* Basic access */ assert_int_equal(arr.len, 0); assert_int_equal(array_push(arr, 5), 0); assert_int_equal(arr.at[0], 5); assert_int_equal(array_tail(arr), 5); array_clear(arr); /* Reserve capacity and fill. */ assert_true(array_reserve(arr, 5) >= 0); for (unsigned i = 0; i < 100; ++i) { ret = array_push(arr, i); assert_true(ret >= 0); } /* Make sure reservation holds. */ assert_true(array_reserve(arr, 5) >= 0); /* Delete elements. */ array_del(arr, 0); while (arr.len > 0) { array_pop(arr); } /* Overfill. */ for (unsigned i = 0; i < 4096; ++i) { ret = array_push(arr, i); assert_true(ret >= 0); } array_clear(arr); }
void hashmap_initialize(hashmap_t* map, size_t buckets, size_t bucketsize) { size_t ibucket; if (bucketsize < HASHMAP_MINBUCKETSIZE) bucketsize = HASHMAP_MINBUCKETSIZE; map->num_buckets = buckets; map->num_nodes = 0; for (ibucket = 0; ibucket < buckets; ++ibucket) { map->bucket[ibucket] = 0; array_reserve(map->bucket[ibucket], bucketsize); } }
static int blast_client_initialize(blast_client_t* client, network_address_t** address) { int iaddr, addrsize = 0; memset(client, 0, sizeof(blast_client_t)); client->address = address; client->state = BLAST_STATE_HANDSHAKE; client->begin_send = time_current(); array_reserve(client->pending, 1024); for (iaddr = 0, addrsize = array_size(client->address); iaddr < addrsize; ++iaddr) { socket_t* sock = udp_socket_allocate(); array_push(client->socks, sock); socket_set_blocking(sock, false); } return BLAST_RESULT_OK; }
int array_resize(struct array* a, unsigned int num) { int result; if (a == NULL) { return EINVAL; } if (num < a->num) { a->num = num; return 0; } if ((result = array_reserve(a, num))) { return result; } memset(&a->a[a->num], (num - a->num) * sizeof(void*), 0); a->num = num; return 0; }
END_TEST START_TEST(test_array_assign) { array_t* array; uint32_t value = 0xdeadbeef; const size_t element_size = sizeof(typeof(value)); const size_t capacity = 1; array = array_create(element_size); ck_assert(array != NULL); ck_assert(array_get(array, typeof(value)) == NULL); array_reserve(array, capacity); ck_assert(array_get(array, typeof(value)) != NULL); ck_assert_int_eq(array_get_capacity(array), capacity); array_at(array, 0, typeof(value)) = value; ck_assert_int_eq((array_get(array, typeof(value)))[0], value); array_destroy(array); }
hashmap_t* hashmap_allocate( unsigned int buckets, unsigned int bucketsize ) { hashmap_t* map; unsigned int ibucket; if( buckets < HASHMAP_MINBUCKETS ) buckets = HASHMAP_MINBUCKETS; if( bucketsize < HASHMAP_MINBUCKETSIZE ) bucketsize = HASHMAP_MINBUCKETSIZE; map = memory_allocate( sizeof( hashmap_t ) + sizeof( hashmap_bucket_t ) * buckets, 0, MEMORY_PERSISTENT ); map->num_buckets = buckets; map->num_nodes = 0; for( ibucket = 0; ibucket < buckets; ++ibucket ) { map->bucket[ibucket] = 0; array_reserve( map->bucket[ibucket], (int)bucketsize ); } return map; }
void array_resize(void *array_, allocator_t *alloc, uint element_size, uint new_size) { void_array *array = array_; array_reserve(array_, alloc, element_size, new_size); array->size = new_size; }
int main(int argc, const char* argv[]) { array_t(int) a = NULL; test(array_size(a) == 0); test(array_capacity(a) == 0); array_alloc(a, 0, destructed_element_count_destructor); test(array_size(a) == 0); test(array_capacity(a) == 0); array_append(a, 1); test(array_size(a) == 1); test(array_capacity(a) >= 1); test(a[0] == 1); array_append(a, 2); test(array_size(a) == 2); test(array_capacity(a) >= 2); test(a[0] == 1); test(a[1] == 2); array_append(a, 3); test(array_size(a) == 3); test(array_capacity(a) >= 3); test(a[0] == 1); test(a[1] == 2); test(a[2] == 3); array_insert(a, 0, 0); test(array_size(a) == 4); test(array_capacity(a) >= 4); test(a[0] == 0); test(a[1] == 1); test(a[2] == 2); test(a[3] == 3); array_reserve(a, 16); test(array_size(a) == 4); test(array_capacity(a) == 16); test(a[0] == 0); test(a[1] == 1); test(a[2] == 2); test(a[3] == 3); array_shrink(a); test(array_size(a) == 4); test(array_capacity(a) == 4); test(a[0] == 0); test(a[1] == 1); test(a[2] == 2); test(a[3] == 3); array_remove(a, 0); test(array_size(a) == 3); test(array_capacity(a) == 4); test(a[0] == 1); test(a[1] == 2); test(a[2] == 3); test(destructed_element_count == 1); destructed_element_count = 0; array_remove_unordered(a,0); test(array_size(a) == 2); test(array_capacity(a) == 4); test(a[0] == 3); test(a[1] == 2); test(destructed_element_count == 1); destructed_element_count = 0; array_clear(a); test(array_size(a) == 0); test(array_capacity(a) >= 0); test(destructed_element_count == 2); destructed_element_count = 0; array_append(a, 0); array_append(a, 1); array_append(a, 2); test(array_size(a) == 3); test(array_capacity(a) >= 3); test(destructed_element_count == 0); array_free(a); test(a == NULL); test(array_size(a) == 0); test(array_capacity(a) == 0); test(destructed_element_count == 3); destructed_element_count = 0; enum { TEST_LENGTH = 1024 }; array_alloc(a, 0, destructed_element_count_destructor); for (int i = 0; i < TEST_LENGTH; ++i) { array_append(a, i); test(a[i] == i); } test(array_size(a) == TEST_LENGTH); test(array_capacity(a) >= TEST_LENGTH); for (int i = 0; i < TEST_LENGTH; ++i) { test(a[i] == i); } { int i = 0; const int* const end = array_end(a); for (int* itr = array_begin(a); itr < end; ++itr) { test(*itr == i++); } } { int i = 0; while (array_size(a)) { test(a[0] == i++); array_remove(a,0); } test(array_size(a) == 0); test(array_capacity(a) >= TEST_LENGTH); test(destructed_element_count == TEST_LENGTH); destructed_element_count = 0; } array_free(a); test(a == NULL); test(array_size(a) == 0); test(array_capacity(a) == 0); array_alloc(a, 0, destructed_element_count_destructor); for (int i = 0; i < TEST_LENGTH; ++i) { array_insert(a, 0, i); } test(array_size(a) == TEST_LENGTH); test(array_capacity(a) >= TEST_LENGTH); for (int i = 0; i < TEST_LENGTH; ++i) { test(a[i] == (TEST_LENGTH - 1) - i); } array_free(a); test(a == NULL); test(array_size(a) == 0); test(array_capacity(a) == 0); puts("array tests passed"); }
ObjectPtr<Array> create_array_with_size(uint32_t sz) { ObjectPtr<Array> array = create_array(); array_reserve(array, sz); return array; }