ERL_NIF_TERM as_ldt_lset_get(ErlNifEnv* env, handle_t* handle, void* obj)
{
ldt_get_args_t* args = (ldt_get_args_t*)obj;
as_status res;
as_error err;
as_list* p_list = NULL;
res = aerospike_lset_filter(&handle->instance, &err, NULL, &args->key, &args->ldt, NULL, NULL,
&p_list);
as_ldt_clean_get_args(env, args);
if(res != AEROSPIKE_OK)
return A_AS_ERROR(env, err);
ERL_NIF_TERM* results;
uint32_t nresults = as_list_size(p_list);
results = malloc(sizeof(ERL_NIF_TERM) * nresults);
as_arraylist_iterator it;
as_arraylist_iterator_init(&it, (const as_arraylist*)p_list);
int i = 0;
// See if the elements match what we expect.
while (as_arraylist_iterator_has_next(&it)) {
const as_val* p_val = as_arraylist_iterator_next(&it);
results[i++] = make_nif_term_from_as_val(env, p_val);
}
as_list_destroy(p_list);
p_list = NULL;
ERL_NIF_TERM returnValue;
returnValue = enif_make_list_from_array(env, results, nresults);
free(results);
return A_OK_VALUE(env, returnValue);
}
static int check_bin4(as_record * rec, scan_check * check)
{
as_val * bin = (as_val *) as_record_get(rec, "bin4");
if ( !bin ) {
error("Expected a value in bin('%s'), but got null", "bin4");
return !(check->failed = true);
}
as_list * list = as_list_fromval(bin);
if ( !list ) {
error("Expected a list in bin('%s'), but got type %d", "bin4", as_val_type(bin));
return !(check->failed = true);
}
int sz = as_list_size(list);
if ( sz < 3 ) {
error("Expected list size of %d, but got %d", 3, sz);
return !(check->failed = true);
}
for ( int i = 0; i < sz; i++ ) {
as_val * val = as_list_get(list, i);
if ( !val ) {
error("Expecting value at %d, but got null", i);
return !(check->failed = true);
}
as_integer * ival = as_integer_fromval(val);
if ( !ival ) {
error("Expecting integer at %d, but got type %d", i, as_val_type(val));
return !(check->failed = true);
}
}
return !(check->failed = false);
}
as_arraylist arglist;
as_arraylist_inita(&arglist, 4);
as_arraylist_append_int64(&arglist, 1);
as_arraylist_append_int64(&arglist, 2);
as_arraylist_append_int64(&arglist, 3);
as_arraylist_append_int64(&arglist, 4);
as_result * res = as_success_new(NULL);
int rc = as_module_apply_record(&mod_lua, &ctx, "lists", "create", rec, (as_list *) &arglist, res);
assert_int_eq( rc, 0 );
assert_true( res->is_success );
assert_not_null( res->value );
as_list * rlist = (as_list *) res->value;
assert_int_eq( as_list_size(rlist), 4 );
assert_int_eq( as_list_get_int64(rlist,0), 1 );
assert_int_eq( as_list_get_int64(rlist,1), 2 );
assert_int_eq( as_list_get_int64(rlist,2), 3 );
assert_int_eq( as_list_get_int64(rlist,3), 4 );
as_rec_destroy(rec);
as_arraylist_destroy(&arglist);
as_result_destroy(res);
}
TEST( list_udf_2, "get the size of a list" )
{
as_arraylist list;
as_arraylist_init(&list, 4, 5);
as_arraylist_append_int64(&list, 1);
#include <aerospike/as_arraylist.h>
#include <aerospike/as_arraylist_iterator.h>
#include <aerospike/as_integer.h>
#include <aerospike/as_list.h>
#include <aerospike/as_list_iterator.h>
#include <aerospike/as_msgpack.h>
#include <aerospike/as_serializer.h>
/******************************************************************************
* TEST CASES
*****************************************************************************/
TEST( types_arraylist_empty, "as_arraylist is empty" ) {
as_arraylist l;
as_arraylist_init(&l,0,0);
assert( as_list_size((as_list *) &l) == 0 );
as_list_destroy((as_list *) &l);
}
#if 0 // DEBUG
static void print_list(const char *msg, const as_list *l) {
char *s = as_val_tostring(l);
fprintf(stderr, "%s %s\n",msg,s);
cf_free(s);
}
#endif
TEST( types_arraylist_cap10_blk0, "as_arraylist w/ capacity 10, block_size 0" ) {
int rc = 0;
