int main() {
int a = 5;
int b = 10;
int c = 20;
List* list = list_create();
Iterator* iterator = list_iterator(list);
assert(false == iterator_has_next(iterator));
iterator_destroy(iterator);
list_push(list, &a);
list_push(list, &b);
list_push(list, &c);
iterator = list_iterator(list);
assert(true == iterator_has_next(iterator));
assert(&a == iterator_next(iterator));
assert(&b == iterator_next(iterator));
assert(&c == iterator_next(iterator));
assert(false == iterator_has_next(iterator));
iterator_destroy(iterator);
return 0;
}
/**
* Assign vector element with an exist vector container range.
*/
void vector_assign_range(vector_t* pvec_vector, vector_iterator_t it_begin, vector_iterator_t it_end)
{
iterator_t it_dest;
iterator_t it_src;
bool_t b_result = false;
/* assign the two iterator is as the same type as pvec_vector */
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_begin));*/
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_end));*/
assert(_vector_same_vector_iterator_type(pvec_vector, it_begin));
assert(_vector_same_vector_iterator_type(pvec_vector, it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
/* copy value from range [it_begin, it_end) for each element */
vector_resize(pvec_vector, iterator_distance(it_begin, it_end));
for(it_dest = vector_begin(pvec_vector), it_src = it_begin;
!iterator_equal(it_dest, vector_end(pvec_vector)) && !iterator_equal(it_src, it_end);
it_dest = iterator_next(it_dest), it_src = iterator_next(it_src))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_dest), _VECTOR_ITERATOR_COREPOS(it_src), &b_result);
assert(b_result);
}
assert(iterator_equal(it_dest, vector_end(pvec_vector)) && iterator_equal(it_src, it_end));
}
/**
* Initialize data within range [it_begin, it_end) according to deque element data type.
*/
void _deque_init_elem_range_auxiliary(deque_t* pdeq_deque, deque_iterator_t it_begin, deque_iterator_t it_end)
{
deque_iterator_t it_iter;
assert(pdeq_deque != NULL);
assert(_deque_is_inited(pdeq_deque) || _deque_is_created(pdeq_deque));
assert(_deque_iterator_belong_to_deque(_GET_DEQUE_CONTAINER(it_begin), it_begin));
assert(_deque_iterator_belong_to_deque(_GET_DEQUE_CONTAINER(it_end), it_end));
assert(iterator_equal(it_begin, it_end) || _deque_iterator_before(it_begin, it_end));
/* initialize new elements */
if(_GET_DEQUE_TYPE_STYLE(pdeq_deque) == _TYPE_CSTL_BUILTIN)
{
/* get element type name */
char s_elemtypename[_TYPE_NAME_SIZE + 1];
_type_get_elem_typename(_GET_DEQUE_TYPE_NAME(pdeq_deque), s_elemtypename);
for(it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter))
{
_GET_DEQUE_TYPE_INIT_FUNCTION(pdeq_deque)(_deque_iterator_get_pointer_auxiliary(it_iter), s_elemtypename);
}
}
else
{
for(it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter))
{
bool_t t_result = _GET_DEQUE_TYPE_SIZE(pdeq_deque);
_GET_DEQUE_TYPE_INIT_FUNCTION(pdeq_deque)(_deque_iterator_get_pointer_auxiliary(it_iter), &t_result);
assert(t_result);
}
}
}
/**
* Test the first vector is less than the second vector.
*/
bool_t vector_less(const vector_t* cpvec_first, const vector_t* cpvec_second)
{
bool_t b_result = false;
vector_iterator_t it_first;
vector_iterator_t it_second;
assert(cpvec_first != NULL);
assert(cpvec_second != NULL);
assert(_vector_is_inited(cpvec_first));
assert(_vector_is_inited(cpvec_second));
assert(_vector_same_type(cpvec_first, cpvec_second));
for(it_first = vector_begin(cpvec_first), it_second = vector_begin(cpvec_second);
!iterator_equal(it_first, vector_end(cpvec_first)) && !iterator_equal(it_second, vector_end(cpvec_second));
it_first = iterator_next(it_first), it_second = iterator_next(it_second))
{
b_result = _GET_VECTOR_TYPE_SIZE(cpvec_first);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_result);
/* if any element in first vector are less then the second return true */
if(b_result)
{
return true;
}
b_result = _GET_VECTOR_TYPE_SIZE(cpvec_first);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_second), _VECTOR_ITERATOR_COREPOS(it_first), &b_result);
/* if any element in first vector are greater then the second return false */
if(b_result)
{
return false;
}
}
/* if the first n elements in two vector are equal then compare the vector size */
return vector_size(cpvec_first) < vector_size(cpvec_second) ? true : false;
}
/**
* Initialize vector container with an exist vector range.
*/
void vector_init_copy_range(vector_t* pvec_dest, vector_iterator_t it_begin, vector_iterator_t it_end)
{
vector_iterator_t it_dest;
vector_iterator_t it_src;
bool_t b_result = false;
assert(pvec_dest != NULL);
assert(_vector_is_created(pvec_dest));
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_begin), it_begin));
assert(_vector_iterator_belong_to_vector(_VECTOR_ITERATOR_CONTAINER(it_end), it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
assert(_vector_same_vector_iterator_type(pvec_dest, it_begin));
assert(_vector_same_vector_iterator_type(pvec_dest, it_end));
/* initialize all elements with default value */
vector_init_n(pvec_dest, iterator_distance(it_begin, it_end));
/* copy values for range */
for(it_dest = vector_begin(pvec_dest), it_src = it_begin;
!iterator_equal(it_dest, vector_end(pvec_dest)) && !iterator_equal(it_src, it_end);
it_dest = iterator_next(it_dest), it_src = iterator_next(it_src))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_dest);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_dest)(_VECTOR_ITERATOR_COREPOS(it_dest), _VECTOR_ITERATOR_COREPOS(it_src), &b_result);
assert(b_result);
}
assert(iterator_equal(it_dest, vector_end(pvec_dest)) && iterator_equal(it_src, it_end));
}
static void request_game_list(const char *s) {
game_t *g;
struct iterator it = list_iterator(&public_games);
while ((g = iterator_next(&it))) {
g->active = FALSE;
}
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 2;
pthread_mutex_lock(&pub_m);
mcp_send(0x05, "%w 00 00 00 00 %s 00", request_id, s);
request_id++;
pthread_cond_timedwait(&pub_cv, &pub_m, &ts);
it = list_iterator(&public_games);
while ((g = iterator_next(&it))) {
if (!g->active) {
iterator_remove(&it);
plugin_debug("mcp game", "removing inactive game\n");
}
}
dump_game_list(&public_games);
pthread_mutex_unlock(&pub_m);
}
int test_list(void)
{
int ret = 0;
allocator_t *allocator;
iterator_t it,next;
container_t *ct;
/*
*allocator = allocator_creator(ALLOCATOR_TYPE_SYS_MALLOC);
*/
allocator = allocator_creator(ALLOCATOR_TYPE_CDS_MALLOC);
allocator_cds_init(allocator, 0, 0, 1024);
dbg_str(DBG_CONTAINER_DETAIL,"list allocator addr:%p",allocator);
ct = container_creator(CONTAINER_TYPE_LIST,allocator);
container_list_init(ct,sizeof(struct test));
/*
*container_push_front(ct,&test);
*container_push_front(ct,&test2);
*container_push_front(ct,&test3);
*/
dbg_str(DBG_CONTAINER_DETAIL,"run at here");
container_push_back(ct,&test);
container_push_back(ct,&test2);
container_push_back(ct,&test3);
dbg_str(DBG_CONTAINER_DETAIL,"iter ordinal");
for( it = container_begin(ct);
!iterator_equal(it,container_end(ct));
it = iterator_next(it))
{
print_test((struct test *)iterator_get_pointer(it));
}
dbg_str(DBG_CONTAINER_DETAIL,"iter insert test");
int i = 0;
for( it = container_begin(ct);
!iterator_equal(it,container_end(ct));
it = iterator_next(it),i++)
{
if(i == 1){
break;
}
}
dbg_str(DBG_CONTAINER_DETAIL,"it list_head:%p",it.pos.list_head_p);
container_insert(ct,it,&test4);
dbg_str(DBG_CONTAINER_DETAIL,"iter delte test");
container_for_each_safe(it,next,ct){
//container_delete(ct,it);
print_test((struct test *)iterator_get_pointer(it));
}
cstl_iterator deque_insert_range(cstl_deque *cd, cstl_iterator pos, cstl_iterator beging, cstl_iterator end)
{
int distance = iterator_distance(end, beging);
pos = deque_insert_n(cd, pos, distance, cd->_begin);
cstl_iterator new_pos = pos;
for (int i = 0; i < distance; i++)
{
iterator_store(new_pos, iterator_load(beging));
iterator_next(&new_pos);
iterator_next(&beging);
}
return pos;
}
/**
* Assign slist with variable argument of specificed element.
*/
void _slist_assign_elem_varg(slist_t* pslist_slist, size_t t_count, va_list val_elemlist)
{
slist_iterator_t it_iter;
_slistnode_t* pt_varg = NULL;
bool_t b_result = false;
assert(pslist_slist != NULL);
assert(_slist_is_inited(pslist_slist));
slist_resize(pslist_slist, t_count);
/* get varg value */
pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
assert(pt_varg != NULL);
_slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg);
/* copy value from varg */
for (it_iter = slist_begin(pslist_slist);
!iterator_equal(it_iter, slist_end(pslist_slist));
it_iter = iterator_next(it_iter)) {
b_result = _GET_SLIST_TYPE_SIZE(pslist_slist);
_GET_SLIST_TYPE_COPY_FUNCTION(pslist_slist)(
((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, pt_varg->_pby_data, &b_result);
assert(b_result);
}
/* destroy varg value */
_slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg);
_alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
}
_export void module_cleanup() {
struct iterator it = list_iterator(&items);
item_t *i;
while ((i = iterator_next(&it))) {
if (!is_blocked(i)) {
logitem("failed to pick ");
if (i->amount > 1) logitem("%i ", i->amount);
if (i->ethereal) logitem("ethereal ");
if (i->quality != 0x00) logitem("%s ", qualities[i->quality]);
logitem("%s", lookup_item(i));
if (i->quality != 0x00) logitem(" (%i)", i->level);
if (i->sockets > 0) logitem(" [%i]", i->sockets);
if (setting("Debug")->b_var) logitem(" distance: %i", i->distance); // test pickit
logitem("\n");
}
}
list_clear(&items);
gold = 0;
routine_scheduled = FALSE;
}
/**
* Transfer the range [it_begin, it_end) to position it_pos+1.
*/
void _slist_transfer_after(slist_iterator_t it_pos, slist_iterator_t it_begin, slist_iterator_t it_end)
{
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_pos), it_pos));
assert(!iterator_equal(it_pos, slist_end(_SLIST_ITERATOR_CONTAINER(it_pos))));
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_begin), it_begin));
assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_end), it_end));
assert(_SLIST_ITERATOR_CONTAINER(it_begin) == _SLIST_ITERATOR_CONTAINER(it_end));
assert(iterator_equal(it_begin, it_end) || _slist_iterator_before(it_begin, it_end));
assert(_slist_same_slist_iterator_type(_SLIST_ITERATOR_CONTAINER(it_pos), it_begin));
/* empty range */
if(iterator_equal(it_begin, it_end))
{
return;
}
/* same slist container */
if(_SLIST_ITERATOR_CONTAINER(it_pos) == _SLIST_ITERATOR_CONTAINER(it_begin))
{
iterator_t it_iter = iterator_next(it_pos);
assert(iterator_equal(it_iter, it_begin) || iterator_equal(it_iter, it_end) ||
_slist_iterator_before(it_iter, it_begin) || _slist_iterator_before(it_end, it_iter));
if(iterator_equal(it_iter, it_begin) || iterator_equal(it_iter, it_end))
{
return;
}
}
slist_insert_after_range(_SLIST_ITERATOR_CONTAINER(it_pos), it_pos, it_begin, it_end);
slist_erase_range(_SLIST_ITERATOR_CONTAINER(it_begin), it_begin, it_end);
}
static String* create_json(String* content, Project* project, Message* message, List* elements, List* element_types)
{
Iterator* it;
String* base_url_a = string_new();
base_url_a = get_base_url(base_url_a);
string_appendf(content, "{project:{name: \"%s\"}, ticket:{id: %d, url: \"%s/%s/ticket/%d\",fields:[",
string_rawstr(project->name),
message->id,
string_rawstr(base_url_a),
g_project_code_4_url,
message->id);
string_free(base_url_a);
foreach (it, element_types) {
ElementType* et = it->element;
String* field_a = string_new();
String* name_a = string_new();
String* value_a = string_new();
string_append(name_a, string_rawstr(et->name));
escape_quot(name_a);
string_append(value_a, get_element_value(elements, et));
escape_quot(value_a);
string_appendf(field_a, "{name:\"%s\", value:\"%s\"}",
string_rawstr(name_a),
string_rawstr(value_a));
string_free(name_a);
string_free(value_a);
string_append(content, string_rawstr(field_a));
string_free(field_a);
if (iterator_next(it)) string_append(content, ",");
}
/**
* Initialize vector with variable argument list of specified element.
*/
void _vector_init_elem_varg(vector_t* pvec_vector, size_t t_count, va_list val_elemlist)
{
void* pv_varg = NULL;
bool_t b_result = false;
vector_iterator_t it_iter;
assert(pvec_vector != NULL);
assert(_vector_is_created(pvec_vector));
/* initialize vector_t */
vector_init_n(pvec_vector, t_count);
if(t_count > 0)
{
/* 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);
/* copy varg value to each element */
for(it_iter = vector_begin(pvec_vector);
!iterator_equal(it_iter, vector_end(pvec_vector));
it_iter = iterator_next(it_iter))
{
/* copy from varg */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg value and free memory */
_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 lib_watch_event(struct inotify_event *e, const char *path, void *payload)
{
lib_entry entry;
lib_t *lib=(lib_t*)payload;
size_t l=strlen(path)+strlen(e->name)+1;
char *f=malloc(l+1);
strcpy(f, path);
strcat(f, e->name);
debug(ll, "watch_even '%s%s'", path, e->name);
if(e->mask&IN_CLOSE_WRITE || e->mask&IN_CREATE || e->mask&IN_MOVED_TO)
{
struct stat buf;
stat(f, &buf);
if(S_ISDIR(buf.st_mode))
{
f[l-1]='/';
f[l]=0;
parse_dir(lib, &f, l, &entry);
}
else
parse_file(lib, f, &entry);
}
else if(e->mask&IN_DELETE || e->mask&IN_DELETE_SELF || e->mask&IN_MOVED_FROM)
{
iterator_t *it=chunked_list_iterator(lib->entries);
while(iterator_has_next(it))
{
lib_entry *e=iterator_next(it);
if(strncmp(f, e->path, l-1)==0)
iterator_remove(it);
}
}
}
/**
* Shrink deque at begin.
*/
void _deque_shrink_at_begin(deque_t* pdeq_deque, size_t t_shrinksize)
{
deque_iterator_t it_oldbegin;
deque_iterator_t it_newbegin;
deque_iterator_t it_iter;
_mappointer_t ppby_map = NULL;
bool_t b_result = false;
assert(pdeq_deque != NULL);
assert(_deque_is_inited(pdeq_deque));
it_oldbegin = deque_begin(pdeq_deque);
t_shrinksize = t_shrinksize < deque_size(pdeq_deque) ? t_shrinksize : deque_size(pdeq_deque);
it_newbegin = iterator_next_n(deque_begin(pdeq_deque), t_shrinksize);
assert(_deque_iterator_belong_to_deque(pdeq_deque, it_newbegin));
/* destroy all elements */
for(it_iter = it_oldbegin; !iterator_equal(it_iter, it_newbegin); it_iter = iterator_next(it_iter))
{
b_result = _GET_DEQUE_TYPE_SIZE(pdeq_deque);
_GET_DEQUE_TYPE_DESTROY_FUNCTION(pdeq_deque)(_deque_iterator_get_pointer_auxiliary(it_iter), &b_result);
assert(b_result);
}
pdeq_deque->_t_start = it_newbegin;
for(ppby_map = _GET_DEQUE_MAP_POINTER(pdeq_deque->_t_start) - 1; ppby_map >= _GET_DEQUE_MAP_POINTER(it_oldbegin); --ppby_map)
{
_alloc_deallocate(&pdeq_deque->_t_allocator, *ppby_map, _GET_DEQUE_TYPE_SIZE(pdeq_deque), _DEQUE_ELEM_COUNT);
*ppby_map = NULL;
}
}
int lib_write(lib_t *lib)
{
int fd;
iterator_t *it;
fd=open(lib->dbfile, O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
if(fd)
{
write(fd, &lib->entries->size, sizeof(size_t));
it=chunked_list_iterator(lib->entries);
while(iterator_has_next(it))
{
lib_entry *e=iterator_next(it);
size_t len=strlen(e->path)+e->group->len+e->album->len+strlen(e->name)+4;
write(fd, &len, sizeof(size_t));
write(fd, e->path, strlen(e->path)+1);
write(fd, e->group->str, e->group->len+1);
write(fd, e->album->str, e->album->len+1);
write(fd, e->name, strlen(e->name)+1);
}
free(it);
close(fd);
}
debug(ll, "done writing libfile");
}
/**
* Remove element that specificed by variable argument slist from slist container.
*/
void _slist_remove_varg(slist_t* pslist_slist, va_list val_elemlist)
{
slist_iterator_t it_iter; /* for iterate */
_slistnode_t* pt_varg = NULL;
bool_t b_less = false;
bool_t b_greater = false;
/* test the pointer is valid */
assert(pslist_slist != NULL);
assert(_slist_is_inited(pslist_slist));
pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
assert(pt_varg != NULL);
_slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg);
it_iter = slist_begin(pslist_slist);
while (!iterator_equal(it_iter, slist_end(pslist_slist))) {
b_less = b_greater = _GET_SLIST_TYPE_SIZE(pslist_slist);
_GET_SLIST_TYPE_LESS_FUNCTION(pslist_slist)(
pt_varg->_pby_data, ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, &b_less);
_GET_SLIST_TYPE_LESS_FUNCTION(pslist_slist)(
((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, pt_varg->_pby_data, &b_greater);
if (b_less || b_greater) {
it_iter = iterator_next(it_iter);
} else {
it_iter = slist_erase(pslist_slist, it_iter);
}
}
_slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg);
_alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
}
static bool complete_records(void *parsed_arguments, const char *current_argument, size_t current_argument_len, DPtrArray *possibilities, void *UNUSED(data))
{
domain_t *d;
bool request_success;
domain_record_argument_t *args;
args = (domain_record_argument_t *) parsed_arguments;
assert(NULL != args->domain);
if ((request_success = (COMMAND_SUCCESS == get_domain_records(args->domain, &d, FALSE, NULL)))) {
Iterator it;
hashtable_to_iterator(&it, d->records);
for (iterator_first(&it); iterator_is_valid(&it); iterator_next(&it)) {
record_t *r;
r = iterator_current(&it, NULL);
if (0 == strncmp(r->name, current_argument, current_argument_len)) {
dptrarray_push(possibilities, (void *) r->name);
}
}
iterator_close(&it);
}
return request_success;
}
Style *
new_style(const char *name, LList *spec)
{
Style *style;
Iterator *it;
StrBuf *prebuf;
StrBuf *postbuf;
style = xmalloc(sizeof(Style));
style->name = xstrdup(name);
prebuf = strbuf_new();
postbuf = strbuf_new();
for (it = llist_iterator(spec); iterator_has_next(it); ) {
StyleInfo *info = iterator_next(it);
if (info->type == STYLEINFO_PRE) {
strbuf_append(prebuf, info->value);
} else if (info->type == STYLEINFO_POST) {
strbuf_prepend(postbuf, info->value);
} else if (info->type == STYLEINFO_STYLE) {
const Style *add_style = info->value;
strbuf_append(prebuf, add_style->pre_string);
strbuf_prepend(postbuf, add_style->post_string);
}
}
style->pre_string = strbuf_free_to_string(prebuf);
style->post_string = strbuf_free_to_string(postbuf);
style->refs = 1;
return style;
}
void *check_lib(void *arg)
{
size_t l;
char *n;
lib_entry *entry;
lib_t *lib=(lib_t *)arg;
iterator_t *it=chunked_list_iterator(lib->entries);
info(ll, "starting checker");
while(iterator_has_next(it))
{
lib_entry *e=iterator_next(it);
char *f=lib_canonize(lib, e->path);
debug(ll, "cheking '%s'", f);
if(access(f, R_OK))
iterator_remove(it);
free(f);
}
l=lib->base_path_size+1;
n=malloc(l);
memcpy(n, lib->base_path, l);
entry=malloc(sizeof(lib_entry));
parse_dir(lib, &n, l, entry);
free(n);
free(entry);
}
static command_status_t fetch_domains(domain_set_t *ds, bool force, error_t **error)
{
if (!ds->uptodate || force) {
request_t *req;
bool request_success;
json_document_t *doc;
req = request_new(REQUEST_FLAG_SIGN, HTTP_GET, NULL, error, API_BASE_URL "/domain");
request_success = request_execute(req, RESPONSE_JSON, (void **) &doc, error);
request_destroy(req);
if (request_success) {
Iterator it;
json_value_t root;
root = json_document_get_root(doc);
hashtable_clear(ds->domains);
json_array_to_iterator(&it, root);
for (iterator_first(&it); iterator_is_valid(&it); iterator_next(&it)) {
json_value_t v;
v = (json_value_t) iterator_current(&it, NULL);
hashtable_put(ds->domains, 0, json_get_string(v), domain_new(), NULL); // ds->domains has strdup as key_duper, don't need to strdup it ourself
}
iterator_close(&it);
ds->uptodate = TRUE;
json_document_destroy(doc);
} else {
return COMMAND_FAILURE;
}
}
return COMMAND_SUCCESS;
}
/**
* Return an iterator that addresses the first element in the hashtable.
*/
_hashtable_iterator_t _hashtable_begin(const _hashtable_t* cpt_hashtable)
{
vector_iterator_t it_bucket;
_hashtable_iterator_t it_iter = _create_hashtable_iterator();
assert(cpt_hashtable != NULL);
assert(_hashtable_is_inited(cpt_hashtable));
for(it_bucket = vector_begin(&cpt_hashtable->_vec_bucket);
!iterator_equal(it_bucket, vector_end(&cpt_hashtable->_vec_bucket));
it_bucket = iterator_next(it_bucket))
{
_GET_HASHTABLE_BUCKETPOS(it_iter) = _GET_VECTOR_COREPOS(it_bucket);
if(*(_hashnode_t**)_GET_HASHTABLE_BUCKETPOS(it_iter) != NULL)
{
_GET_HASHTABLE_COREPOS(it_iter) = (_byte_t*)*(_hashnode_t**)_GET_HASHTABLE_BUCKETPOS(it_iter);
break;
}
}
if(iterator_equal(it_bucket, vector_end(&cpt_hashtable->_vec_bucket)))
{
assert(_GET_HASHTABLE_COREPOS(it_iter) == NULL);
_GET_HASHTABLE_BUCKETPOS(it_iter) = _GET_VECTOR_COREPOS(it_bucket);
}
_GET_HASHTABLE_POINTER(it_iter) = (_hashtable_t*)cpt_hashtable;
return it_iter;
}
/**
* Finds the position of the first element in an ordered range that has a value greater than or equivalent to a specified value,
* where the ordering criterion may be specified by a binary predicate.
*/
forward_iterator_t _algo_lower_bound_if_varg(forward_iterator_t it_first, forward_iterator_t it_last, bfun_t bfun_op, va_list val_elemlist)
{
void* pv_value = NULL;
bool_t b_result = false;
size_t t_len = 0;
size_t t_halflen = 0;
iterator_t it_middle;
assert(_iterator_valid_range(it_first, it_last, _FORWARD_ITERATOR));
if (bfun_op == NULL) {
bfun_op = _fun_get_binary(it_first, _LESS_FUN);
}
pv_value = _iterator_allocate_init_elem(it_first);
_type_get_varg_value(_iterator_get_typeinfo(it_first), val_elemlist, pv_value);
if (strncmp(_iterator_get_typebasename(it_first), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) {
t_len = iterator_distance(it_first, it_last);
while (t_len > 0) {
t_halflen = t_len >> 1;
it_middle = iterator_advance(it_first, t_halflen);
(*bfun_op)(iterator_get_pointer(it_middle), string_c_str((string_t*)pv_value), &b_result);
if (b_result) { /* *it_middle < value */
it_first = iterator_next(it_middle);
t_len = t_len - t_halflen - 1;
} else {
t_len = t_halflen;
}
}
} else {
/* get name functions */
static inline str* __get_avp_name(int id, map_t m)
{
map_iterator_t it;
int **idp;
if (map_first(m, &it) < 0) {
LM_ERR("map doesn't exist\n");
return NULL;
}
for (;;) {
if (!iterator_is_valid(&it))
return NULL;
idp = (int**)iterator_val(&it);
if (!idp) {
LM_ERR("[BUG] while getting avp name\n");
return NULL;
}
if (p2int(*idp) == id)
return iterator_key(&it);
if (iterator_next(&it) < 0)
return NULL;
}
}
void
t_field_map(void)
{
pool_reference list_pool = pool_create(LIST_TYPE_ID);
CU_ASSERT_NOT_EQUAL_FATAL(list_pool, NULL_POOL);
global_reference head = pool_alloc(&list_pool);
pool_iterator itr = iterator_new(&list_pool, &head);
size_t list_size = 10000;
for (size_t i = 0 ; i < list_size ; ++i) {
iterator_set_field(itr, 1, &i);
iterator_list_insert(itr, pool_alloc(&list_pool));
itr = iterator_next(list_pool, itr);
}
pool_reference long_pool = pool_create(LONG_TYPE_ID);
CU_ASSERT_NOT_EQUAL_FATAL(long_pool, NULL_POOL);
CU_ASSERT_EQUAL(field_map(list_pool, &long_pool, 1, square), 0);
uint64_t *result = pool_to_array(long_pool);
int cmp_error_count = 0;
for (size_t i = 0 ; i < list_size ; ++i) {
cmp_error_count += i*i != result[i];
}
CU_ASSERT_EQUAL(cmp_error_count, 0);
iterator_destroy(&itr);
pool_destroy(&long_pool);
pool_destroy(&list_pool);
}
void lib_str_reset(lib_t *lib)
{
chunked_string_clear(lib->lib_str);
chunked_string_add(lib->lib_str, "{");
iterator_t *it=chunked_list_iterator(lib->entries);
lib_entry *e=NULL;
while(iterator_has_next(it))
{
if(e!=NULL)
chunked_string_add(lib->lib_str, ",");
e=iterator_next(it);
chunked_string_add(lib->lib_str, "\"");
append(lib, e->path);
chunked_string_add(lib->lib_str, "\":{\"title\":\"");
append(lib, e->name);
chunked_string_add(lib->lib_str, "\",\"group\":\"");
append(lib, e->group->str);
chunked_string_add(lib->lib_str, "\",\"album\":\"");
append(lib, e->album->str);
chunked_string_add(lib->lib_str, "\",\"track\":");
snprintf(buf, 5, "%d", e->track);
chunked_string_add(lib->lib_str, buf);
chunked_string_add(lib->lib_str, "}");
}
chunked_string_add(lib->lib_str, "}");
iterator_dispose(it);
}
/**
* Assign vector with variable argument list of specificed element.
*/
void _vector_assign_elem_varg(vector_t* pvec_vector, size_t t_count, va_list val_elemlist)
{
iterator_t it_iter;
iterator_t it_begin;
iterator_t it_end;
bool_t b_result = false;
void* pv_varg = NULL;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/* get value from varg */
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);
/* copy value from varg for each element */
vector_resize(pvec_vector, t_count);
it_begin = vector_begin(pvec_vector);
it_end = vector_end(pvec_vector);
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg and free memory */
_vector_destroy_varg_value_auxiliary(pvec_vector, pv_varg);
_alloc_deallocate(&pvec_vector->_t_allocator, pv_varg, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
}
/**
* Destroy vector container auxiliary function.
*/
void _vector_destroy_auxiliary(vector_t* pvec_vector)
{
vector_iterator_t it_iter;
vector_iterator_t it_begin;
vector_iterator_t it_end;
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector) || _vector_is_created(pvec_vector));
/* destroy all elements */
it_begin = vector_begin(pvec_vector);
it_end = vector_end(pvec_vector);
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), &b_result);
assert(b_result);
}
/* free vector memory */
if (pvec_vector->_pby_start != NULL) {
_alloc_deallocate(&pvec_vector->_t_allocator, pvec_vector->_pby_start, _GET_VECTOR_TYPE_SIZE(pvec_vector),
(pvec_vector->_pby_endofstorage - pvec_vector->_pby_start) / _GET_VECTOR_TYPE_SIZE(pvec_vector));
}
_alloc_destroy(&pvec_vector->_t_allocator);
pvec_vector->_pby_start = NULL;
pvec_vector->_pby_finish = NULL;
pvec_vector->_pby_endofstorage = NULL;
}
static void clean_profiles(unsigned int ticks, void *param)
{
map_iterator_t it, del;
unsigned int count;
struct dlg_profile_table *profile;
prof_value_info_t *rp;
void **dst;
int i;
for (profile = profiles; profile; profile = profile->next) {
if (!profile->has_value || profile->repl_type != REPL_PROTOBIN)
continue;
for (i = 0; i < profile->size; i++) {
lock_set_get(profile->locks, i);
if (map_first(profile->entries[i], &it) < 0) {
LM_ERR("map does not exist\n");
goto next_entry;
}
while (iterator_is_valid(&it)) {
dst = iterator_val(&it);
if (!dst || !*dst) {
LM_ERR("[BUG] bogus map[%d] state\n", i);
goto next_val;
}
count = prof_val_get_count(dst);
if (!count) {
del = it;
if (iterator_next(&it) < 0)
LM_DBG("cannot find next iterator\n");
rp = (prof_value_info_t *) iterator_delete(&del);
if (rp) {
free_profile_val_t(rp);
/*if (rp->noval)
shm_free(rp->noval);
shm_free(rp);*/
}
continue;
}
next_val:
if (iterator_next(&it) < 0)
break;
}
next_entry:
lock_set_release(profile->locks, i);
}
}
}
/**
* Test the two vectors are equal.
*/
bool_t vector_equal(const vector_t* cpvec_first, const vector_t* cpvec_second)
{
vector_iterator_t it_first;
vector_iterator_t it_second;
bool_t b_less = false;
bool_t b_greater = false;
assert(cpvec_first != NULL);
assert(cpvec_second != NULL);
assert(_vector_is_inited(cpvec_first));
assert(_vector_is_inited(cpvec_second));
/* same vector container */
if(cpvec_first == cpvec_second)
{
return true;
}
/* the element type is equal */
if(!_vector_same_type(cpvec_first, cpvec_second))
{
return false;
}
/* the element count is equal */
if(vector_size(cpvec_first) != vector_size(cpvec_second))
{
return false;
}
/* each element is equal */
for(it_first = vector_begin(cpvec_first), it_second = vector_begin(cpvec_second);
!iterator_equal(it_first, vector_end(cpvec_first)) && !iterator_equal(it_second, vector_end(cpvec_second));
it_first = iterator_next(it_first), it_second = iterator_next(it_second))
{
b_less = _GET_VECTOR_TYPE_SIZE(cpvec_first);
b_greater = _GET_VECTOR_TYPE_SIZE(cpvec_second);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_first)(_VECTOR_ITERATOR_COREPOS(it_first), _VECTOR_ITERATOR_COREPOS(it_second), &b_less);
_GET_VECTOR_TYPE_LESS_FUNCTION(cpvec_second)(_VECTOR_ITERATOR_COREPOS(it_second), _VECTOR_ITERATOR_COREPOS(it_first), &b_greater);
if(b_less || b_greater)
{
return false;
}
}
assert(iterator_equal(it_first, vector_end(cpvec_first)) &&
iterator_equal(it_second, vector_end(cpvec_second)));
return true;
}
