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; }