Exemple #1
0
void
case_list_iter()
{
    struct list *list = list();
    char *s1 = "s1", *s2 = "s2", *s3 = "s3";
    list_push(list, s1);
    list_push(list, s2);
    list_push(list, s3);
    struct list_iter *iter = list_iter(list);
    assert(iter->list == list);
    assert(iter->node == list->head);
    assert(list_iter_next(iter) == s1);
    assert(list_iter_next(iter) == s2);
    assert(list_iter_next(iter) == s3);
    list_iter_seek_tail(iter);
    assert(list_iter_prev(iter) == s3);
    assert(list_iter_prev(iter) == s2);
    assert(list_iter_prev(iter) == s1);
    list_iter_free(iter);
    int i = 0;
    struct list_node *node;
    list_each(list, node) {
        char *s = node->data;
        assert(s[1] - 49 == i);
        i += 1;
    }
Exemple #2
0
/* =============================================================================
 * net_findDescendants
 * -- Contents of bitmapPtr set to 1 if descendants, else 0
 * -- Returns false if id is not root node (i.e., has cycle back id)
 * =============================================================================
 */
bool_t
net_findDescendants (net_t* netPtr,
                     long id,
                     bitmap_t* descendantBitmapPtr,
                     queue_t* workQueuePtr)
{
    bool_t status;

    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;
    assert(descendantBitmapPtr->numBit == vector_getSize(nodeVectorPtr));

    bitmap_clearAll(descendantBitmapPtr);
    queue_clear(workQueuePtr);

    {
        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, id);
        list_t* childIdListPtr = nodePtr->childIdListPtr;
        list_iter_t it;
        list_iter_reset(&it, childIdListPtr);
        while (list_iter_hasNext(&it, childIdListPtr)) {
            long childId = (long)list_iter_next(&it, childIdListPtr);
            status = bitmap_set(descendantBitmapPtr, childId);
            assert(status);
            status = queue_push(workQueuePtr, (void*)childId);
            assert(status);
        }
    }

    while (!queue_isEmpty(workQueuePtr)) {
        long childId = (long)queue_pop(workQueuePtr);
        if (childId == id) {
            queue_clear(workQueuePtr);
            return FALSE;
        }
        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, childId);
        list_t* grandChildIdListPtr = nodePtr->childIdListPtr;
        list_iter_t it;
        list_iter_reset(&it, grandChildIdListPtr);
        while (list_iter_hasNext(&it, grandChildIdListPtr)) {
            long grandChildId = (long)list_iter_next(&it, grandChildIdListPtr);
            if (!bitmap_isSet(descendantBitmapPtr, grandChildId)) {
                status = bitmap_set(descendantBitmapPtr, grandChildId);
                assert(status);
                status = queue_push(workQueuePtr, (void*)grandChildId);
                assert(status);
            }
        }
    }

    return TRUE;
}
Exemple #3
0
/* =============================================================================
 * net_findAncestors
 * -- Contents of bitmapPtr set to 1 if ancestor, else 0
 * -- Returns false if id is not root node (i.e., has cycle back id)
 * =============================================================================
 */
bool_t
net_findAncestors (net_t* netPtr,
                   long id,
                   bitmap_t* ancestorBitmapPtr,
                   queue_t* workQueuePtr)
{
    bool_t status;

    vector_t* nodeVectorPtr = LocalLoad(&netPtr->nodeVectorPtr);
    assert(LocalLoad(&ancestorBitmapPtr->numBit) == vector_getSize(nodeVectorPtr));

    bitmap_clearAll(ancestorBitmapPtr);
    queue_clear(workQueuePtr);

    {
        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, id);
        list_t* parentIdListPtr = LocalLoad(&nodePtr->parentIdListPtr);
        list_iter_t it;
        list_iter_reset(&it, parentIdListPtr);
        while (list_iter_hasNext(&it, parentIdListPtr)) {
            long parentId = (long)list_iter_next(&it, parentIdListPtr);
            status = bitmap_set(ancestorBitmapPtr, parentId);
            assert(status);
            status = queue_push(workQueuePtr, (void*)parentId);
            assert(status);
        }
    }

    while (!queue_isEmpty(workQueuePtr)) {
        long parentId = (long)queue_pop(workQueuePtr);
        if (parentId == id) {
            queue_clear(workQueuePtr);
            return FALSE;
        }
        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, parentId);
        list_t* grandParentIdListPtr = LocalLoad(&nodePtr->parentIdListPtr);
        list_iter_t it;
        list_iter_reset(&it, grandParentIdListPtr);
        while (list_iter_hasNext(&it, grandParentIdListPtr)) {
            long grandParentId = (long)list_iter_next(&it, grandParentIdListPtr);
            if (!bitmap_isSet(ancestorBitmapPtr, grandParentId)) {
                status = bitmap_set(ancestorBitmapPtr, grandParentId);
                assert(status);
                status = queue_push(workQueuePtr, (void*)grandParentId);
                assert(status);
            }
        }
    }

    return TRUE;
}
Exemple #4
0
boxdir * boxtree_add_folder(const char * path, const char * id, jobj * folder)
{
	boxdir * aDir;
	boxfile * aFile, * part;
	list_iter it, pit;
	jobj * obj, *item;
	char * type;

	aDir = boxdir_create();
	aDir->id = strdup(id);
	
	if(options.verbose) syslog(LOG_DEBUG, "Adding %s", path);
	obj = jobj_get(folder, "entries");
	it = list_get_iter(obj->children);
	for(; it; it = list_iter_next(it)) {
        	item = list_iter_getval(it);
		aFile = obj_to_file(item);

        	type = jobj_getval(item, "type");
        	if(!strcmp(type,"folder")) list_append(aDir->folders, aFile);
        	else {
        		if(options.splitfiles && ends_with(aFile->name, PART_SUFFIX))
        			list_insert_sorted_comp(aDir->pieces, aFile, filename_compare);
			else list_append(aDir->files, aFile);
		}
        	free(type);
	}
	
	if(options.splitfiles) {
        	it = list_get_iter(aDir->files);
        	pit = list_get_iter(aDir->pieces);
        	
        	for(; pit; pit = list_iter_next(pit)) {
        		part = (boxfile*)list_iter_getval(pit);
        		find_file_for_part(part->name, &it);
        		if(it) {
        			aFile = (boxfile*)list_iter_getval(it);
        			aFile->size+=part->size;
			} else {
				syslog(LOG_WARNING, "Stale file part %s found", part->name );
				it = list_get_iter(aDir->files);
			}
		}
	}

	xmlHashAddEntry(allDirs, path, aDir);
	return aDir;	
}
Exemple #5
0
int main ( int argc, char *argv[] )
{
   List* list = list_create ( sizeof ( int ),EqualInt );
   int t;
   ListNode* n;
   int i;
   for ( i=0; i<10; ++i )
      list_push_back ( list,createInt ( &t,rand() ) );
   /*list_foreach(list,printInt);*/
   ListIter iter = list_get_iter ( list );
   while ( list_iter_hasNext ( iter ) )
   {
      printInt ( list_iter_next ( iter ) );
   }
   printf ( "\n" );
   list_pop_back ( list );
   list_foreach ( list,incInt );
   list_foreach ( list,printInt );
   printf ( "\n" );
   n = list_find_first_node ( list,createInt ( &t,846930887 ) );
   list_erase_node ( list,n );
   list_foreach ( list,printInt );
   list_delete ( list );
   return 0;
}
Exemple #6
0
/* =============================================================================
 * hashtable_iter_next
 * =============================================================================
 */
void*
hashtable_iter_next (hashtable_iter_t* itPtr, hashtable_t* hashtablePtr)
{
    long bucket;
    long numBucket = hashtablePtr->numBucket;
    list_t** buckets = hashtablePtr->buckets;
    list_iter_t it = itPtr->it;
    void* dataPtr = NULL;

    for (bucket = itPtr->bucket; bucket < numBucket; /* inside body */) {
        list_t* chainPtr = hashtablePtr->buckets[bucket];
        if (list_iter_hasNext(&it, chainPtr)) {
            pair_t* pairPtr = (pair_t*)list_iter_next(&it, chainPtr);
            dataPtr = pairPtr->secondPtr;
            break;
        }
        /* May use dummy bucket; see allocBuckets() */
        list_iter_reset(&it, buckets[++bucket]);
    }

    itPtr->bucket = bucket;
    itPtr->it = it;

    return dataPtr;
}
Exemple #7
0
/* =============================================================================
 * isCycle
 * =============================================================================
 */
static bool_t
isCycle (vector_t* nodeVectorPtr, net_node_t* nodePtr)
{
    switch (nodePtr->mark) {
        case NET_NODE_MARK_INIT: {
            nodePtr->mark = NET_NODE_MARK_TEST;
            list_t* childIdListPtr = nodePtr->childIdListPtr;
            list_iter_t it;
            list_iter_reset(&it, childIdListPtr);
            while (list_iter_hasNext(&it, childIdListPtr)) {
                long childId = (long)list_iter_next(&it, childIdListPtr);
                net_node_t* childNodePtr =
                    (net_node_t*)vector_at(nodeVectorPtr, childId);
                if (isCycle(nodeVectorPtr, childNodePtr)) {
                    return TRUE;
                }
            }
            break;
        }
        case NET_NODE_MARK_TEST:
            return TRUE;
        case NET_NODE_MARK_DONE:
            return FALSE;
            break;
        default:
            assert(0);
    }

    nodePtr->mark = NET_NODE_MARK_DONE;
    return FALSE;
}
Exemple #8
0
const char *       errors_describe                (intmax_t errnum){ // {{{
	err_item               key;
	err_item              *item;
	err_item              *dynamic_list;
	void                  *iter              = NULL;
	uintmax_t              errnum_pos        = -errnum;
	uintmax_t              errnum_emod       = errnum_pos / ESTEP;
	
	if(errnum_emod == 0){
		if( (key.errmsg = strerror(errnum_pos)) != NULL)
			return key.errmsg;
		
	}else if(errnum_emod < DYNAMIC_EMODULE_START){
		// core errors list
		key.errnum = errnum;
		if((item = bsearch(&key, errs_list,
			errs_list_nelements, errs_list_size,
			&err_bsearch_int)) != NULL
		)
			return item->errmsg;
	}else{
		// dynamic errs list
		while( (dynamic_list = list_iter_next(&dynamic_errors, &iter)) != NULL){
			for(item = dynamic_list; item->errnum != 0; item++){
				if(errnum == item->errnum)
					return item->errmsg;
			}
		}
	}
	return "unknown error";
} // }}}
Exemple #9
0
static void
printHashtable (hashtable_t* hashtablePtr)
{
    long i;
    hashtable_iter_t it;

    printf("[");
    hashtable_iter_reset(&it, hashtablePtr);
    while (hashtable_iter_hasNext(&it, hashtablePtr)) {
        printf("%li ", *((long*)(hashtable_iter_next(&it, hashtablePtr))));
    }
    puts("]");

    /* Low-level to see structure */
    for (i = 0; i < hashtablePtr->numBucket; i++) {
        list_iter_t it;
        printf("%2li: [", i);
        list_iter_reset(&it, hashtablePtr->buckets[i]);
        while (list_iter_hasNext(&it, hashtablePtr->buckets[i])) {
            void* pairPtr = list_iter_next(&it, hashtablePtr->buckets[i]);
            printf("%li ", *(long*)(((pair_t*)pairPtr)->secondPtr));
        }
        puts("]");
    }
}
Exemple #10
0
void list_dump(list *l, const char * fmt)
{
	list_iter it = list_get_iter(l);
	printf("list size is %d\n", list_size(l));
	while(it) {
		printf(fmt, list_iter_getval(it));
		it = list_iter_next(it);
	}	
}
Exemple #11
0
/* boxtree_* functions and helpers
   used at mount time to fill the allDirs hash
*/
void find_file_for_part(const char * pname, list_iter * it)
{
    boxfile  * f;
    while(*it) {
        f = (boxfile*) list_iter_getval(*it);
        if(!strncmp(f->name, pname, strlen(f->name))) break;
        *it = list_iter_next(*it);
    }
}
void game_lifespan_checks(game_t *gm)
{
	list_iter_t iter;
	player_t *pl;

	list_iter_init(&iter, gm->ga_players, FWD);
	while ((pl = list_iter_next(&iter))) {
		player_lifespan_check(pl, gm->ga_freq);
	}
}
Exemple #13
0
static void
printList (list_t* listPtr)
{
    list_iter_t it;
    printf("[");
    list_iter_reset(&it, listPtr);
    while (list_iter_hasNext(&it, listPtr)) {
        printf("%li ", *((long*)(list_iter_next(&it, listPtr))));
    }
    puts("]");
}
Exemple #14
0
void
case_list_iter()
{
    struct list *list = list();
    char *s1 = "s1", *s2 = "s2", *s3 = "s3";
    list_push(list, s1);
    list_push(list, s2);
    list_push(list, s3);
    struct list_iter *iter = list_iter(list);
    assert(iter->list == list);
    assert(iter->node == list->head);
    assert(list_iter_next(iter) == s1);
    assert(list_iter_next(iter) == s2);
    assert(list_iter_next(iter) == s3);
    list_iter_seek_tail(iter);
    assert(list_iter_prev(iter) == s3);
    assert(list_iter_prev(iter) == s2);
    assert(list_iter_prev(iter) == s1);
    list_iter_free(iter);
    list_free(list);
}
Exemple #15
0
jobj * jobj_array_item(const jobj * obj, int at)
{
	list_iter it;
	int i;
	if(obj->type != T_ARR) return NULL;
	if(at >= list_size(obj->children)) return NULL;
	
	it = list_get_iter(obj->children);
	for(i=0; i<at; ++i) it = list_iter_next(it);
	
	return (jobj*) list_iter_getval(it);
}
Exemple #16
0
static struct hashmap_pair *_hashmap_list_find(hashmap_t map, list_t list, int key){
    list_iter_t it = list_iter_create(list);
    struct hashmap_pair *p, *ret = NULL;
    while ((p = list_iter_next(it)) != NULL) {
        if (map->eq(p->key, key)) {
            ret = p;
            break;
        }
    }
    list_iter_destroy(&it);
    return ret;
}
Exemple #17
0
player_t *game_find_pl(game_t *gm, unsigned int id)
{
	list_iter_t it;
	player_t *pl = NULL;

	for (list_iter_init(&it, gm->ga_players, FWD);
		(pl = list_iter_access(&it)); list_iter_next(&it)) {
		if (pl->p_id == id)
			return (pl);
	}
	return (pl);
}
Exemple #18
0
static ssize_t data_format_t_convert_to(data_t *src, fastcall_convert_to *fargs){ // {{{
	ssize_t                ret;
	format_t               value;
	uintmax_t              transfered;
	keypair_t             *kp;
	void                  *iter              = NULL;
	char                  *string            = "(unknown)";
	
	if(fargs->dest == NULL || src->ptr == NULL)
		return -EINVAL;
	
	value = *(format_t *)src->ptr;
	
	switch(fargs->format){
		case FORMAT(config):;
		case FORMAT(clean):;
		case FORMAT(human):;
			// find in static keys first
			for(kp = &formats[0]; kp->key_str != NULL; kp++){
				if(kp->key_val == value){
					string = kp->key_str;
					goto found;
				}
			}
			
		#ifdef RESOLVE_DYNAMIC_KEYS
			// find in dynamic keys
			list_rdlock(&dynamic_formats);
			while( (kp = list_iter_next(&dynamic_formats, &iter)) != NULL){
				if(kp->key_val == value){
					string = kp->key_str;
					list_unlock(&dynamic_formats);
					goto found;
				}
			}
			list_unlock(&dynamic_formats);
		#endif
		
		found:;
			fastcall_write r_write = { { 5, ACTION_WRITE }, 0, string, strlen(string) };
			ret        = data_query(fargs->dest, &r_write);
			transfered = r_write.buffer_size;
			break;
		
		default:
			return -ENOSYS;
	}
	if(fargs->header.nargs >= 5)
		fargs->transfered = transfered;
	
	return ret;
} // }}}		
Exemple #19
0
list_iter   boxpath_next_part(boxpath * bpath, list_iter it)
{
	boxfile * part;
	
	it = list_iter_next(it);
	if(it) {
		part = (boxfile*) list_iter_getval(it);
		if(strncmp(bpath->file->name, part->name, strlen(bpath->file->name)))
			return NULL;
	}

	return it;	
}
Exemple #20
0
struct list_iter list_erase(struct list *l,struct list_iter it)
{
    assert(l);
    struct list_iter it_next = list_iter_next(it);
    struct node *n = it.n;
    struct node *P = n->pre;
    struct node *N = n->next;
    P->next = N;
    N->pre = P;
    free(n);
    --l->size;
    return it_next;
}
Exemple #21
0
static void
printTable (table_t* tablePtr)
{
    long i;

    for (i = 0; i < tablePtr->numBucket; i++) {
        list_iter_t it;
        printf("%2i: [", i);
        list_iter_reset(&it, tablePtr->buckets[i]);
        while (list_iter_hasNext(&it, tablePtr->buckets[i])) {
            printf("%li ", *(long*)list_iter_next(&it, tablePtr->buckets[i]));
        }
        puts("]");
    }
}
Exemple #22
0
void hashmap_destroy(hashmap_t *map){
    assert(map != NULL);
    assert((*map) != NULL);
    for (int i = 0; i < (*map)->capacity; i++) {
        list_iter_t it = list_iter_create((*map)->lists[i]);
        struct hashmap_pair *p;
        while ((p = list_iter_next(it)) != NULL) {
            free(p);
        }
        list_iter_destroy(&it);
        list_destroy((*map)->lists + i);
    }
    free((*map)->lists);
    free((*map));
    *map = NULL;
}
Exemple #23
0
void jobj_free(jobj * obj)
{
	list_iter it;

	if(obj->type = T_VAL) {
		free(obj->value);
		return;
	}

	it = list_get_iter(obj->children);
	for(; it; it = list_iter_next(it)) {
		jobj_free(list_iter_getval(it));
	}
	list_free(obj->children);
	free(obj);
}
Exemple #24
0
jobj * jobj_get(const jobj * obj, const char * key)
{
	list_iter it;

	if(obj->type == T_VAL) return NULL;

	it = list_get_iter(obj->children);
        jobj * item;

        for(; it; it = list_iter_next(it)) {
		item = list_iter_getval(it);
		if(!strcmp(item->key, key)) return item;
	}

        return NULL;
}
Exemple #25
0
list_iter   boxpath_first_part(boxpath * bpath)
{
	list_iter it;
	boxfile * part;
	if(!boxpath_getfile(bpath)) return NULL;
	
	it = list_get_iter(bpath->dir->pieces);
	while(it && (filename_compare(bpath->file, list_iter_getval(it)) > 0))
		it = list_iter_next(it);
	if(it) {
		part = (boxfile*) list_iter_getval(it);
		if(strncmp(bpath->base, part->name, strlen(bpath->base)))
			return NULL;
	}
	
	return it;
}
Exemple #26
0
/* =============================================================================
 * net_hasEdge
 * =============================================================================
 */
bool_t
net_hasEdge (net_t* netPtr, long fromId, long toId)
{
    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;
    net_node_t* childNodePtr = (net_node_t*)vector_at(nodeVectorPtr, toId);
    list_t* parentIdListPtr = childNodePtr->parentIdListPtr;

    list_iter_t it;
    list_iter_reset(&it, parentIdListPtr);
    while (list_iter_hasNext(&it, parentIdListPtr)) {
        long parentId = (long)list_iter_next(&it, parentIdListPtr);
        if (parentId == fromId) {
            return TRUE;
        }
    }

    return FALSE;
}
Exemple #27
0
boxfile * obj_to_file(jobj * obj)
{
	list_iter it;
	jobj * item;
	boxfile * f = (boxfile*) malloc(sizeof(boxfile));
	
	memset(f, 0, sizeof(boxfile));
	it = list_get_iter(obj->children);
	for(; it; it = list_iter_next(it)) {
		item = list_iter_getval(it);
		if(!strcmp(item->key,"id")) f->id = strdup(item->value);
		else if(!strcmp(item->key, "size")) f->size = atoll(item->value);
		else if(!strcmp(item->key, "name")) f->name = strdup(item->value);
		else if(!strcmp(item->key, "created_at")) f->ctime = unix_time(item->value);
		else if(!strcmp(item->key, "modified_at")) f->mtime = unix_time(item->value);
	}

	return f;
}
Exemple #28
0
int boxpath_getfile(boxpath * bpath)
{
    list_iter it;
    boxfile * aFile;

    /* check for obvious cases */
    if(!bpath) return FALSE;
    if(bpath->file) return TRUE;

    it = list_get_iter(bpath->is_dir ? bpath->dir->folders : bpath->dir->files);
    for(; it; it = list_iter_next(it)) {
        aFile = (boxfile*)list_iter_getval(it);
        if(!strcmp(aFile->name, bpath->base)) {
            bpath->file = aFile;
            return TRUE;
        }
    }
    return FALSE;

}
Exemple #29
0
/* =============================================================================
 * net_isPath
 * =============================================================================
 */
bool_t
net_isPath (net_t* netPtr,
            long fromId,
            long toId,
            bitmap_t* visitedBitmapPtr,
            queue_t* workQueuePtr)
{
    bool_t status;

    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;
    assert(visitedBitmapPtr->numBit == vector_getSize(nodeVectorPtr));

    bitmap_clearAll(visitedBitmapPtr);
    queue_clear(workQueuePtr);

    status = queue_push(workQueuePtr, (void*)fromId);
    assert(status);

    while (!queue_isEmpty(workQueuePtr)) {
        long id = (long)queue_pop(workQueuePtr);
        if (id == toId) {
            queue_clear(workQueuePtr);
            return TRUE;
        }
        status = bitmap_set(visitedBitmapPtr, id);
        assert(status);
        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, id);
        list_t* childIdListPtr = nodePtr->childIdListPtr;
        list_iter_t it;
        list_iter_reset(&it, childIdListPtr);
        while (list_iter_hasNext(&it, childIdListPtr)) {
            long childId = (long)list_iter_next(&it, childIdListPtr);
            if (!bitmap_isSet(visitedBitmapPtr, childId)) {
                status = queue_push(workQueuePtr, (void*)childId);
                assert(status);
            }
        }
    }

    return FALSE;
}
Exemple #30
0
// Move a dir to another path in the tree,
// recursively updating all the child entries in allDirs
void	boxtree_movedir(const char * from, const char * to)
{
	boxdir * aDir = xmlHashLookup(allDirs, from);
        list_iter it;
        char * newfrom, * newto, *name;
	if(!aDir) {
	  syslog(LOG_ERR, "no such directory %s", from);
	  return;
	}
        for (it=list_get_iter(aDir->folders); it; it = list_iter_next(it)) {
            name = ((boxfile*)list_iter_getval(it))->name;
            newfrom = pathappend(from, name);
            newto   = pathappend(to,   name);
            boxtree_movedir(newfrom, newto);
            free(newfrom); free(newto);
        }
	//LOCKDIR(aDir);
	xmlHashRemoveEntry(allDirs, from, NULL);
	xmlHashAddEntry(allDirs, to, aDir);
	//UNLOCKDIR(aDir);
}