C++ (Cpp) array_queue_create Exemples

Exemple #1

Fichier : splay_tree.c Projet : Incarnation-p-lee/libds

static inline void
splay_tree_destroy_i(s_splay_tree_t *tree)
{
    s_array_queue_t *queue;
    s_splay_tree_t *splay_node;

    assert_exit(splay_tree_structure_legal_ip(tree));

    queue = array_queue_create();
    array_queue_enter(queue, tree);

    while (!array_queue_empty_p(queue)) {
        splay_node = array_queue_leave(queue);

        if (splay_node->left != NULL) {
            array_queue_enter(queue, splay_node->left);
        }
        if (splay_node->right != NULL) {
            array_queue_enter(queue, splay_node->right);
        }

        doubly_linked_list_destroy(&splay_node->list);
        memory_cache_free(splay_node);
    }

    array_queue_destroy(&queue);
}

Exemple #2

Fichier : splay_tree.c Projet : Incarnation-p-lee/libds

static inline void
splay_tree_iterate_i(s_splay_tree_t *tree, void (*handler)(void *))
{
    s_array_queue_t *queue;
    s_splay_tree_t *splay_node;

    assert_exit(NON_NULL_PTR_P(handler));
    assert_exit(splay_tree_structure_legal_ip(tree));

    queue = array_queue_create();
    array_queue_enter(queue, tree);

    while (!array_queue_empty_p(queue)) {
        splay_node = array_queue_leave(queue);
        handler(splay_node);

        if (splay_node->left) {
            array_queue_enter(queue, splay_node->left);
        }

        if (splay_node->right) {
            array_queue_enter(queue, splay_node->right);
        }
    }

    array_queue_destroy(&queue);
}

Exemple #3

Fichier : leftist_heap.c Projet : Incarnation-p-lee/libds

static inline void
leftist_heap_destroy_i(s_leftist_heap_t *heap)
{
    s_array_queue_t *queue;
    s_leftist_heap_t *node;

    assert_exit(leftist_heap_legal_ip(heap));

    queue = array_queue_create();
    array_queue_enter(queue, heap);

    while (!array_queue_empty_p(queue)) {
        node = array_queue_leave(queue);

        if (LEFTIST_LEFT(node) != NULL) {
            array_queue_enter(queue, LEFTIST_LEFT(node));
        }

        if (LEFTIST_RIGHT(node) != NULL) {
            array_queue_enter(queue, LEFTIST_RIGHT(node));
        }

        leftist_heap_node_destroy(node);
    }

    array_queue_destroy(&queue);
}

Exemple #4

Fichier : trie_tree.c Projet : Incarnation-p-lee/libds

void
trie_tree_destroy(s_trie_tree_t **trie)
{
    s_trie_tree_t *trie_node;
    s_array_queue_t *sub_queue, *queue;

    if (NULL_PTR_P(trie)) {
        return;
    } else if (trie_tree_structure_legal_ip(*trie)) {
        trie_node = *trie;
        queue = array_queue_create();
        array_queue_enter(queue, trie_node);

        while (!array_queue_empty_p(queue)) {
            trie_node = array_queue_leave(queue);
            sub_queue = trie_node->sub_queue;

            while (!array_queue_empty_p(sub_queue)) {
                array_queue_enter(queue, array_queue_leave(sub_queue));
            }

            trie_tree_node_destroy(trie_node);
        }

        array_queue_destroy(&queue);
        *trie = NULL;
    }
}

Exemple #5

Fichier : main_test.c Projet : unanao/c-epoll-message-framework

int main()
{
	queue = array_queue_create(QUEUE_SIZE);	
	test_producer_consumer();

	DEBUG_DBG("exit\n");
	array_queue_destroy(queue);	
}

Exemple #6

Fichier : nfa_closure.c Projet : Incarnation-p-lee/scil

static inline s_fa_closure_t *
nfa_closure_create(s_range_uint32_t *range)
{
    s_fa_closure_t *closure;

    assert_exit(range);

    closure = dp_malloc(sizeof(*closure));

    closure->c = NULL_CHAR;
    closure->path_queue = array_queue_create();
    closure->collection = array_queue_create();
    closure->bitmap = bitmap_create(range->min, range->max);
    closure->match_dp = nfa_closure_match_dp_create(NFA_MATCH_BUF_MIN);

    return closure;
}

Exemple #7

Fichier : splay_tree.c Projet : Incarnation-p-lee/libds

static inline sint32
splay_tree_height_i(s_splay_tree_t *tree)
{
    sint32 height;
    s_splay_tree_t *splay_node;
    s_array_queue_t *queue_master, *queue_slave;

    if (!tree) {
        return -1;
    } else {
        height = -1;
        splay_node = tree;

        queue_slave = array_queue_create();
        queue_master = array_queue_create();
        array_queue_enter(queue_master, splay_node);

        while (!array_queue_empty_p(queue_master)) {
            splay_node = array_queue_leave(queue_master);

            if (splay_node->left) {
                array_queue_enter(queue_slave, splay_node->left);
            }

            if (splay_node->right) {
                array_queue_enter(queue_slave, splay_node->right);
            }

            if (array_queue_empty_p(queue_master)) {
                height++;
                swap_pointer((void **)&queue_master, (void **)&queue_slave);
            }
        }

        array_queue_destroy(&queue_master);
        array_queue_destroy(&queue_slave);

        return height;
    }
}

Exemple #8

Fichier : trie_tree.c Projet : Incarnation-p-lee/libds

static inline s_trie_tree_t *
trie_tree_node_create(uint32 val)
{
    s_trie_tree_t *trie;

    trie = dp_malloc(sizeof(*trie));
    trie->sub_queue = array_queue_create();

    trie->val = val;
    trie->is_deleted = trie->is_terminal = false;

    return trie;
}

Exemple #9

Fichier : array_queue.c Projet : Timsley/DataStructures

void array_queue_main_test(void)
{
    ArrQueue * q = array_queue_create();

    array_queue_in(q, 1);
    array_queue_in(q, 2);
    array_queue_in(q, 3);
    array_queue_in(q, 4);
    array_queue_out(q);
    array_queue_out(q);
    array_queue_in(q, 5);
    array_queue_in(q, 6);
    array_queue_in(q, 7);

    array_queue_traverse(q);
}