C++ (Cpp) slist_push_front Examples

Example #1

File: test.c Project: zoujiaqing/gbase

int main()
{
    int data[LOOP];
    int i, res;
    int* p;
    struct slist_t* sl;
    sl = slist_init();
    assert(sl);

    for (i = 0; i < LOOP; ++ i) {
        data[i] = rand() % LOOP;
        res = slist_push_front(sl, &data[i]);
        assert(0 == res);
        res = slist_push_back(sl, &data[i]);
        assert(0 == res);
    }
    printf("list count=%d\n", slist_count(sl));

    for (i = LOOP-1; i >= 0; -- i) {
        res = slist_find(sl, &data[i]);
        assert(0 == res);
        p = slist_pop_front(sl);
        assert(p == &data[i]);
        p = slist_pop_back(sl);
        assert(p == &data[i]);
        res = slist_find(sl, &data[i]);
        assert(res < 0);
    }
    printf("list count=%d\n", slist_count(sl));

    slist_release(sl);
    sl = 0;
    return 0;
}

Example #2

File: curlp.c Project: gaccob/gbase

static void
_curlp_client_gc(curlp_t* cp, curlc_t* cc) {
    if (cp && cc && cp->free_list) {
        curl_multi_remove_handle(cp->mhandle, curlc_handle(cc));
        curlc_finish(cc);
        slist_push_front(cp->free_list, cc);
    }
}

Example #3

File: reactor_epoll.c Project: tsingzhen/gbase

int epoll_unregister(struct reactor_t* reactor, struct handler_t* h)
{
    if (!reactor || !reactor->data || !h) return -1;
    epoll_t* epoll = (epoll_t*)reactor->data;
    // add to expire-list
    slist_push_front(epoll->expired, h);
    return _epoll_set(epoll, h, EPOLL_CTL_DEL, 0);
}

Example #4

File: curl_pool.c Project: zoujiaqing/gbase

void _curl_pool_client_gc(curl_pool_t* cp,
                          struct curl_client_t* cc)
{
    if (cp && cc && cp->free_list) {
        curl_multi_remove_handle(cp->mhandle, curl_client_handle(cc));
        curl_client_finish_req(cc);
        slist_push_front(cp->free_list, cc);
    }
}

Example #5

File: ut_cstl_slist_iterator.c Project: coderXing/libcstl

void test__slist_iterator_next__successfully(void** state)
{
    slist_iterator_t it_iter;
    slist_t* pslist = create_slist(int);

    slist_init_elem(pslist, 1, 100);
    slist_push_front(pslist, 200);
    it_iter = slist_begin(pslist);
    assert_true(*(int*)iterator_get_pointer(it_iter) == 200);
    it_iter = _slist_iterator_next(it_iter);
    assert_true(*(int*)iterator_get_pointer(it_iter) == 100);

    slist_destroy(pslist);
}

Example #6

File: frboutmodule.c Project: ChristianFrisson/gephex

struct OutputDriver* output_open(const char* driver_name,
                                 const char* server_name)
{
    struct output_id id;
    slist_iterator_t it ;
    struct output_descriptor* od = 0;

    id.driver_name = (char*) driver_name;
    id.server_name = (char*) server_name;
    it = slist_find_if(s_outputs, id_equals, &id);


    if (it == slist_end(s_outputs))
    {
        /*      char buffer[TEMP_BUF_SIZE];
        snprintf(buffer, sizeof(buffer),
                 "Creating new output descriptor: '%s:%s'",
                 driver_name, server_name);
                 s_log(2, buffer);*/

        od = output_descriptor_create(driver_name, server_name);
        slist_push_front(s_outputs, od);
    }
    else
    {
        od = (struct output_descriptor*) slist_iter_deref(it);
    }

    assert(od->ref_count >= 0);

    // create drv if necessary
    if (od->ref_count == 0)
    {
        od->drv = lookup_driver(driver_name);
    }

    // increase refcount
    if (od->drv != 0)
    {
        ++od->ref_count;
    }

    return od->drv;
}

Example #7

File: test_base_slist.c Project: gaccob/gbase

int
test_base_slist(const char* param) {
    struct slist_t* sl = slist_create();
    if (!sl) {
        fprintf(stderr, "slist create fail\n");
        return -1;
    }

    rand_seed(time(NULL));
    int loop = param ? atoi(param) : 32;
    int data[loop];
    for (int i = 0; i < loop; ++ i) {
        data[i] = (int)(rand_gen()) % loop;
        int res = slist_push_front(sl, &data[i]);
        CHECK(sl, res == 0, "slist push front fail");

        res = slist_push_back(sl, &data[i]);
        CHECK(sl, res == 0, "slist push back fail");
    }

    CHECK(sl, slist_size(sl) == 2 * loop, "slist size fail");

    for (int i = loop - 1; i >= 0; -- i) {
        int res = slist_find(sl, &data[i]);
        CHECK(sl, res == 0, "slist find fail");

        void* p = slist_pop_front(sl);
        CHECK(sl, p == &data[i], "slist pop front fail");

        p = slist_pop_back(sl);
        CHECK(sl, p == &data[i], "slist pop back fail");

        res = slist_find(sl, &data[i]);
        CHECK(sl, res < 0, "slist find fail");
    }

    CHECK(sl, slist_size(sl) == 0, "slist size fail");

    slist_release(sl);
    return 0;
}

Example #8

File: curl_pool.c Project: zoujiaqing/gbase

curl_pool_t* curl_pool_init()
{
    int32_t i = 0;
    struct curl_client_t* cc = NULL;
    curl_pool_t* cp = (curl_pool_t*)MALLOC(sizeof(*cp));
    if (!cp) goto CURL_FAIL;
    memset(cp, 0, sizeof(*cp));

    cp->size = CURL_POOL_DEFAULT_SIZE;
    cp->free_list = slist_init();
    if (!cp->free_list) goto CURL_FAIL1;

    cp->clients = hash_init(_curl_pool_hash, _curl_pool_cmp, cp->size * 13);
    if (!cp->clients) goto CURL_FAIL2;

    cp->mhandle = curl_multi_init();
    if (!cp->mhandle) goto CURL_FAIL3;

    // pre allocate client
    for (i = 0; i < cp->size; ++ i)
    {
        cc = curl_client_init();
        if (cc) {
            slist_push_front(cp->free_list, cc);
            hash_insert(cp->clients, cc);
        }
    }
    return cp;

CURL_FAIL3:
    hash_release(cp->clients);
CURL_FAIL2:
    slist_release(cp->free_list);
CURL_FAIL1:
    FREE(cp);
CURL_FAIL:
    return NULL;
}