vector_t * vector_deep_copy(vector_t * vector, libcontain_copy_func_t vector_valcopy_func)
{
size_t i;
size_t size;
vector_t * retval;
void * val;
rw_spinlock_read_lock(vector->lock);
do
{
size = vector->size;
} while (!size);
retval = vector_new(size);
if (!retval)
goto abort_vector_deep_copy1;
for (i = 0; i < size; i++)
{
val = vector_get(vector, i);
if (val != NULL)
if (vector_put(retval, i, vector_valcopy_func(vector->nodes[i].val)) != 0)
goto abort_vector_deep_copy2;
}
rw_spinlock_read_unlock(vector->lock);
return retval;
abort_vector_deep_copy2:
vector_free(retval);
abort_vector_deep_copy1:
rw_spinlock_read_unlock(vector->lock);
return NULL;
}
static void vector_2(void) {
vector_t v;
CU_ASSERT(vector_init(&v, "my_vector.bin", 1) == 0);
CU_ASSERT(vector_size(&v) == 0);
CU_ASSERT(vector_pages(&v) == 0);
CU_ASSERT(vector_capacity(&v) == 0);
CU_ASSERT(vector_elem_size(&v) == 1);
CU_ASSERT(vector_size(&v, COUNT) == COUNT);
CU_ASSERT(COUNT <= vector_capacity(&v));
CU_ASSERT(COUNT <= vector_size(&v));
CU_ASSERT(3 <= vector_pages(&v));
for (int i=0; i<COUNT; i++) {
unsigned char c = (unsigned char)i;
crc2 = clib_crc32(c, crc2);
CU_ASSERT(vector_put(&v, i, &c) == 0);
}
CU_ASSERT_FATAL(crc2 != 0);
FILE * f = fopen(v.hdr.name, "w");
CU_ASSERT_FATAL(f != NULL);
CU_ASSERT(COUNT < vector_save(&v, f));
fclose(f), f = NULL;
CU_ASSERT(vector_delete(&v) == 0);
}
static struct exp *fn_vector_set(struct exp *args) {
err_ensure(exp_list_length(args) == 3,
"vector-set! requires exactly three arguments, got", args);
struct exp *vector = CAR(args);
struct exp *k = CADR(args);
struct exp *obj = CADDR(args);
err_ensure(IS(vector, VECTOR),
"vector-set! requires a vector argument, got", vector);
err_ensure(IS(k, FIXNUM),
"vector-set! requires a numeric index, got", k);
size_t i = k->value.fixnum;
err_ensure(i >= 0 && i < vector_length(vector->value.vector),
"vector-set! requires a valid index, got", k);
vector_put(vector->value.vector, i, obj);
return OK;
}
int64_t SparseMatrix<VALUE_T>::timed_vector_put(std::vector<std::string> row_key,
std::vector<std::string> column_key,
int64_t time_stamp,
std::vector<VALUE_T> value) {
CHECK_EQ(row_key.size(), column_key.size());
CHECK_EQ(row_key.size(), value.size());
write_lock _lock(KVStorage::_timed_rwmutex);
for (uint64_t i = 0; i < row_key.size(); ++i) {
_timed_storage[time_stamp][row_key[i]][column_key[i]] = value[i];
}
if (_timed_storage.size() >= 3) {
_timed_storage.erase(_timed_storage.begin());
}
vector_put(row_key, column_key, value);
return 1;
}
vector_t * vector_copy(vector_t * vector)
{
size_t size = vector->size;
vector_t * retval = vector_new(size);
if (!retval)
return NULL;
size_t i;
rw_spinlock_read_lock(vector->lock);
for (i = 0; i < size; i++)
if (vector_put(retval, i, vector_get(vector, i)) != 0)
goto abort_vector_copy;
rw_spinlock_read_unlock(vector->lock);
return retval;
abort_vector_copy:
vector_free(retval);
return NULL;
}
