C++ (Cpp) list_first_priv Examples

Example #1

File: list.c Project: DarkSpiritNET/NeoStats

int
list_verify (list_t * list)
{
	lnode_t *node = list_first_priv (list), *nil = list_nil (list);
	listcount_t count = list_count (list);

	if (node->prev != nil) {
		return 0;
	}
	if (count > list->maxcount) {
		return 0;
	}

	while (node != nil && count--) {
		if (node->next->prev != node) {
			return 0;
		}
		node = node->next;
	}

	if (count != 0 || node != nil) {
		return 0;
	}

	return 1;
}

Example #2

File: list.c Project: rexyl/Kazlib-for-data-structure-C

lnode_t *list_find(list_t *list, const void *key, int compare(const void *, const void *))
{
    lnode_t *node;

    for (node = list_first_priv(list); node != list_nil(list); node = node->next) {
        if (compare(lnode_get(node), key) == 0)
            return node;
    }

    return 0;
}

Example #3

File: list.c Project: rexyl/Kazlib-for-data-structure-C

int list_contains(list_t *list, lnode_t *node)
{
    lnode_t *n, *nil = list_nil(list);

    for (n = list_first_priv(list); n != nil; n = lnode_next(n)) {
        if (node == n)
            return 1;
    }

    return 0;
}

Example #4

File: list.c Project: DarkSpiritNET/NeoStats

void
list_process (list_t * list, void *context, void (*function) (list_t * list, lnode_t * lnode, void *context))
{
	lnode_t *node = list_first_priv (list), *next, *nil = list_nil (list);

	while (node != nil) {
		/* check for callback function deleting */
		/* the next node from under us          */
		nassert (list_contains (list, node));
		next = node->next;
		function (list, node, context);
		node = next;
	}
}

Example #5

File: list.c Project: rexyl/Kazlib-for-data-structure-C

void list_return_nodes(list_t *list, lnodepool_t *pool)
{
    lnode_t *lnode = list_first_priv(list), *tmp, *nil = list_nil(list);

    while (lnode != nil) {
        tmp = lnode->next;
        lnode->next = NULL;
        lnode->prev = NULL;
        lnode_return(pool, lnode);
        lnode = tmp;
    }

    list_init(list, list->maxcount);
}

Example #6

File: list.c Project: rexyl/Kazlib-for-data-structure-C

void list_destroy_nodes(list_t *list)
{
    lnode_t *lnode = list_first_priv(list), *nil = list_nil(list), *tmp;

    while (lnode != nil) {
        tmp = lnode->next;
        lnode->next = NULL;
        lnode->prev = NULL;
        lnode_destroy(lnode);
        lnode = tmp;
    }

    list_init(list, list->maxcount);
}

Example #7

File: list.c Project: DarkSpiritNET/NeoStats

void
list_merge (list_t * dest, list_t * sour, int compare (const void *, const void *))
{
	lnode_t *dn, *sn, *tn;
	lnode_t *d_nil = list_nil (dest), *s_nil = list_nil (sour);

	/* Nothing to do if source and destination list are the same. */
	if (dest == sour)
		return;

	/* overflow check */
	nassert (list_count (sour) + list_count (dest) >= list_count (sour));

	/* lists must be sorted */
	nassert (list_is_sorted (sour, compare));
	nassert (list_is_sorted (dest, compare));

	dn = list_first_priv (dest);
	sn = list_first_priv (sour);

	while (dn != d_nil && sn != s_nil) {
		if (compare (lnode_get (dn), lnode_get (sn)) >= 0) {
			tn = lnode_next (sn);
			list_delete (sour, sn);
			list_ins_before (dest, sn, dn);
			sn = tn;
		} else {
			dn = lnode_next (dn);
		}
	}

	if (dn != d_nil)
		return;

	if (sn != s_nil)
		list_transfer (dest, sour, sn);
}

Example #8

File: list.c Project: rexyl/Kazlib-for-data-structure-C

int list_is_sorted(list_t *list, int compare(const void *, const void *))
{
    lnode_t *node, *next, *nil;

    next = nil = list_nil(list);
    node = list_first_priv(list);

    if (node != nil)
        next = lnode_next(node);

    for (; next != nil; node = next, next = lnode_next(next)) {
        if (compare(lnode_get(node), lnode_get(next)) > 0)
            return 0;
    }

    return 1;
}

Example #9

File: list.c Project: rexyl/Kazlib-for-data-structure-C

void list_sort(list_t *list, int compare(const void *, const void *))
{
    list_t extra;
    listcount_t middle;
    lnode_t *node;

    if (list_count(list) > 1) {
        middle = list_count(list) / 2;
        node = list_first_priv(list);

        list_init(&extra, list_count(list) - middle);

        while (middle--)
            node = lnode_next(node);

        list_transfer(&extra, list, node);
        list_sort(list, compare);
        list_sort(&extra, compare);
        list_merge(list, &extra, compare);
    }
    assert (list_is_sorted(list, compare));
}