自学教程：C++ tb_assert_and_check_break函数代码示例

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_bool_t tb_dns_cache_init(){    // enter    tb_spinlock_enter(&g_lock);    // done    tb_bool_t ok = tb_false;    do    {        // init hash        if (!g_cache.hash) g_cache.hash = tb_hash_init(tb_align8(tb_isqrti(TB_DNS_CACHE_MAXN) + 1), tb_item_func_str(tb_false), tb_item_func_mem(sizeof(tb_dns_cache_addr_t), tb_null, tb_null));        tb_assert_and_check_break(g_cache.hash);        // ok        ok = tb_true;    } while (0);    // leave    tb_spinlock_leave(&g_lock);    // failed? exit it    if (!ok) tb_dns_cache_exit();    // ok?    return ok;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_aicp_dns_ref_t tb_aicp_dns_init(tb_aicp_ref_t aicp){    // check    tb_assert_and_check_return_val(aicp, tb_null);    // done    tb_bool_t               ok = tb_false;    tb_aicp_dns_impl_t*     impl = tb_null;    do    {        // make impl        impl = tb_malloc0_type(tb_aicp_dns_impl_t);        tb_assert_and_check_break(impl);        // init aicp        impl->aicp = aicp;        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (impl) tb_aicp_dns_exit((tb_aicp_dns_ref_t)impl);        impl = tb_null;    }    // ok?    return (tb_aicp_dns_ref_t)impl;}

/* ////////////////////////////////////////////////////////////////////////////////////// * test */static tb_void_t tb_sort_int_test_perf(tb_size_t n){    __tb_volatile__ tb_size_t i = 0;    // init data    tb_long_t* data = (tb_long_t*)tb_nalloc0(n, sizeof(tb_long_t));    tb_assert_and_check_return(data);        // init iterator    tb_array_iterator_t array_iterator;    tb_iterator_ref_t   iterator = tb_array_iterator_init_long(&array_iterator, data, n);    // make    for (i = 0; i < n; i++) data[i] = tb_random_range(TB_MINS16, TB_MAXS16);    // sort    tb_hong_t time = tb_mclock();    tb_sort_all(iterator, tb_null);    time = tb_mclock() - time;    // time    tb_trace_i("tb_sort_int_all: %lld ms", time);    // check    for (i = 1; i < n; i++) tb_assert_and_check_break(data[i - 1] <= data[i]);    // free    tb_free(data);}

static tb_bool_t tb_small_pool_item_check(tb_pointer_t data, tb_cpointer_t priv){    // check    tb_fixed_pool_ref_t fixed_pool = (tb_fixed_pool_ref_t)priv;    tb_assert_return_val(fixed_pool && data, tb_false);    // done     tb_bool_t ok = tb_false;    do    {        // the data head        tb_pool_data_head_t* data_head = &(((tb_pool_data_head_t*)data)[-1]);        tb_assertf_break(data_head->debug.magic == TB_POOL_DATA_MAGIC, "invalid data: %p", data);        // the data space        tb_size_t space = tb_fixed_pool_item_size(fixed_pool);        tb_assert_and_check_break(space >= data_head->size);        // check underflow        tb_assertf_break(space == data_head->size || ((tb_byte_t*)data)[data_head->size] == TB_POOL_DATA_PATCH, "data underflow");        // ok        ok = tb_true;    } while (0);    // continue?    return ok;}

tb_mutex_ref_t tb_mutex_init(){    // done    tb_bool_t           ok = tb_false;    tb_spinlock_ref_t   lock = tb_null;    do    {        // make lock        lock = tb_malloc0_type(tb_spinlock_t);        tb_assert_and_check_break(lock);        // init lock        if (!tb_spinlock_init(lock)) break;        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        tb_free(lock);        lock = tb_null;    }    // ok?    return (tb_mutex_ref_t)lock;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_semaphore_ref_t tb_semaphore_init(tb_size_t init){    // done    tb_bool_t   ok = tb_false;    sem_t*      semaphore = tb_null;    do    {        // make semaphore        semaphore = tb_malloc0_type(sem_t);        tb_assert_and_check_break(semaphore);        // init        if (sem_init(semaphore, 0, init) < 0) break;        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (semaphore) tb_free(semaphore);        semaphore = tb_null;    }    // ok?    return (tb_semaphore_ref_t)semaphore;}

static tb_object_dictionary_t* tb_object_dictionary_init_base(){    // done    tb_bool_t                   ok = tb_false;    tb_object_dictionary_t*     dictionary = tb_null;    do    {        // make dictionary        dictionary = tb_malloc0_type(tb_object_dictionary_t);        tb_assert_and_check_break(dictionary);        // init dictionary        if (!tb_object_init((tb_object_ref_t)dictionary, TB_OBJECT_FLAG_NONE, TB_OBJECT_TYPE_DICTIONARY)) break;        // init base        dictionary->base.copy = tb_object_dictionary_copy;        dictionary->base.cler = tb_object_dictionary_cler;        dictionary->base.exit = tb_object_dictionary_exit;        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (dictionary) tb_object_exit((tb_object_ref_t)dictionary);        dictionary = tb_null;    }    // ok?    return dictionary;}

tb_size_t tb_thread_pool_task_post_list(tb_thread_pool_ref_t pool, tb_thread_pool_task_t const* list, tb_size_t size){    // check    tb_thread_pool_impl_t* impl = (tb_thread_pool_impl_t*)pool;    tb_assert_and_check_return_val(impl && list, 0);    // init the post size    tb_size_t post_size = 0;    // enter    tb_spinlock_enter(&impl->lock);    // done    tb_size_t ok = 0;    if (!impl->bstoped)    {        for (ok = 0; ok < size; ok++)        {            // post task            tb_thread_pool_job_t* job = tb_thread_pool_jobs_post_task(impl, &list[ok], &post_size);            tb_assert_and_check_break(job);        }    }    // leave    tb_spinlock_leave(&impl->lock);    // post the workers    if (ok && post_size) tb_thread_pool_worker_post(impl, post_size);    // ok?    return ok;}

tb_iterator_ref_t tb_ifaddrs_itor(tb_ifaddrs_ref_t ifaddrs, tb_bool_t reload){    // check    tb_list_ref_t interfaces = (tb_list_ref_t)ifaddrs;    tb_assert_and_check_return_val(interfaces, tb_null);    // uses the cached interfaces?    tb_check_return_val(reload, (tb_iterator_ref_t)interfaces);     // clear interfaces first    tb_list_clear(interfaces);    // done    tb_long_t sock = -1;    do    {        // make sock        sock = tb_ifaddrs_netlink_socket_init();        tb_assert_and_check_break(sock >= 0);        // load ipaddr        if (!tb_ifaddrs_interface_load(interfaces, sock, RTM_GETADDR)) break;        // load hwaddr        if (!tb_ifaddrs_interface_load(interfaces, sock, RTM_GETLINK)) break;    } while (0);    // exit sock    if (sock >= 0) close(sock);    sock = -1;    // ok?    return (tb_iterator_ref_t)interfaces;}

static tb_object_data_t* tb_object_data_init_base(){    // done    tb_bool_t           ok = tb_false;    tb_object_data_t*   data = tb_null;    do    {        // make data        data = tb_malloc0_type(tb_object_data_t);        tb_assert_and_check_break(data);        // init data        if (!tb_object_init((tb_object_ref_t)data, TB_OBJECT_FLAG_NONE, TB_OBJECT_TYPE_DATA)) break;        // init base        data->base.copy = tb_object_data_copy;        data->base.cler = tb_object_data_cler;        data->base.exit = tb_object_data_exit;                // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (data) tb_object_exit((tb_object_ref_t)data);        data = tb_null;    }    // ok?    return data;}

static tb_oc_number_t* tb_oc_number_init_base(){    // done    tb_bool_t       ok = tb_false;    tb_oc_number_t* number = tb_null;    do    {        // make number        number = tb_malloc0_type(tb_oc_number_t);        tb_assert_and_check_break(number);        // init number        if (!tb_object_init((tb_object_ref_t)number, TB_OBJECT_FLAG_NONE, TB_OBJECT_TYPE_NUMBER)) break;        // init base        number->base.copy   = tb_oc_number_copy;        number->base.exit   = tb_oc_number_exit;        number->base.clear  = tb_oc_number_clear;                // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (number) tb_object_exit((tb_object_ref_t)number);        number = tb_null;    }    // ok?    return number;}

tb_bool_t tb_dns_looker_done(tb_char_t const* name, tb_ipaddr_ref_t addr){    // check    tb_assert_and_check_return_val(name && addr, tb_false);    // try to lookup it from cache first    if (tb_dns_cache_get(name, addr)) return tb_true;    // init looker    tb_dns_looker_ref_t looker = tb_dns_looker_init(name);    tb_check_return_val(looker, tb_false);    // spak    tb_long_t r = -1;    while (!(r = tb_dns_looker_spak(looker, addr)))    {        // wait        r = tb_dns_looker_wait(looker, TB_DNS_LOOKER_TIMEOUT);        tb_assert_and_check_break(r >= 0);    }    // exit    tb_dns_looker_exit(looker);    // ok    return r > 0? tb_true : tb_false;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_bool_t tb_memory_init(tb_allocator_ref_t allocator, tb_byte_t* data, tb_size_t size){    // done    tb_bool_t ok = tb_false;    do    {           // init page        if (!tb_page_init()) break;        // init the native memory        if (!tb_native_memory_init()) break;        // init the allocator        g_allocator = allocator;        // init the large pool data        g_large_pool_data = data;        g_large_pool_size = size;        // init the pool        tb_assert_and_check_break(tb_pool());        // ok        ok = tb_true;    } while (0);    // failed? exit it    if (!ok) tb_memory_exit();        // ok?    return ok;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */static tb_object_ref_t tb_object_json_reader_func_null(tb_object_json_reader_t* reader, tb_char_t type){    // check    tb_assert_and_check_return_val(reader && reader->stream, tb_null);    // init data    tb_static_string_t  data;    tb_char_t           buff[256];    if (!tb_static_string_init(&data, buff, 256)) return tb_null;    // done     tb_object_ref_t null = tb_null;    do    {        // append character        tb_static_string_chrcat(&data, type);        // walk        tb_bool_t failed = tb_false;        while (!failed && tb_stream_left(reader->stream))         {            // need one character            tb_byte_t* p = tb_null;            if (!tb_stream_need(reader->stream, &p, 1) && p)             {                failed = tb_true;                break;            }            // the character            tb_char_t ch = *p;            // append character            if (tb_isalpha(ch)) tb_static_string_chrcat(&data, ch);            else break;            // skip it            tb_stream_skip(reader->stream, 1);        }        // failed?        tb_check_break(!failed);        // check        tb_assert_and_check_break(tb_static_string_size(&data));        // trace        tb_trace_d("null: %s", tb_static_string_cstr(&data));        // null?        if (!tb_stricmp(tb_static_string_cstr(&data), "null")) null = tb_object_null_init();    } while (0);    // exit data    tb_static_string_exit(&data);    // ok?    return null;}

tb_object_ref_t tb_object_data(tb_object_ref_t object, tb_size_t format){       // check    tb_assert_and_check_return_val(object, tb_null);    // done    tb_object_ref_t    odata = tb_null;    tb_size_t       maxn = 4096;    tb_byte_t*      data = tb_null;    do    {        // make data        data = data? (tb_byte_t*)tb_ralloc(data, maxn) : tb_malloc_bytes(maxn);        tb_assert_and_check_break(data);        // writ object to data        tb_long_t size = tb_object_writ_to_data(object, data, maxn, format);            // ok? make the data object        if (size >= 0) odata = tb_object_data_init_from_data(data, size);        // failed? grow it        else maxn <<= 1;    } while (!odata);    // exit data    if (data) tb_free(data);    data = tb_null;    // ok?    return odata;}

tb_aioo_ref_t tb_aiop_addo(tb_aiop_ref_t aiop, tb_socket_ref_t sock, tb_size_t code, tb_cpointer_t priv){    // check    tb_aiop_impl_t* impl = (tb_aiop_impl_t*)aiop;    tb_assert_and_check_return_val(impl && impl->rtor && impl->rtor->addo && sock, tb_null);    tb_assert(tb_aiop_have(aiop, code));    // done    tb_bool_t       ok = tb_false;    tb_aioo_ref_t   aioo = tb_null;    do    {        // init aioo        aioo = tb_aiop_aioo_init(impl, sock, code, priv);        tb_assert_and_check_break(aioo);                // addo aioo        if (!impl->rtor->addo(impl->rtor, (tb_aioo_impl_t*)aioo)) break;        // ok        ok = tb_true;    } while (0);    // failed? remove aioo    if (!ok && aioo)     {        tb_aiop_aioo_exit(impl, aioo);        aioo = tb_null;    }    // ok?    return aioo;}

/* ////////////////////////////////////////////////////////////////////////////////////// * main */ tb_int_t tb_demo_stream_transfer_pool_main(tb_int_t argc, tb_char_t** argv){#if TB_DEMO_TEST_AICP    // done    do    {        // init event        g_event = tb_event_init();        tb_assert_and_check_break(g_event);        // init tasks        tb_char_t** p = &argv[2];        for (; p && *p; p++)        {            // done transfer            if (!tb_transfer_pool_done(tb_transfer_pool(), argv[1], *p, 0, 0, tb_demo_transfer_done_func, tb_null, *p)) break;        }    } while (0);    // wait transfer    while (g_event && tb_transfer_pool_size(tb_transfer_pool()) && tb_event_wait(g_event, -1) > 0);    // exit event    if (g_event) tb_event_exit(g_event);    g_event = tb_null;#else    tb_char_t** p = &argv[2];    for (; p && *p; p++) tb_transfer_done_url(argv[1], *p, 0, tb_demo_transfer_done_func, *p);#endif    return 0;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_lo_scheduler_io_ref_t tb_lo_scheduler_io_init(tb_lo_scheduler_t* scheduler){    // done    tb_bool_t                   ok = tb_false;    tb_lo_scheduler_io_ref_t    scheduler_io = tb_null;    do    {        // init io scheduler        scheduler_io = tb_malloc0_type(tb_lo_scheduler_io_t);        tb_assert_and_check_break(scheduler_io);        // save scheduler        scheduler_io->scheduler = (tb_lo_scheduler_t*)scheduler;        // init poller        scheduler_io->poller = tb_poller_init(tb_null);        tb_assert_and_check_break(scheduler_io->poller);#ifndef TB_CONFIG_MICRO_ENABLE        // init timer and using cache time        scheduler_io->timer = tb_timer_init(TB_SCHEDULER_IO_TIMER_GROW, tb_true);        tb_assert_and_check_break(scheduler_io->timer);        // init ltimer and using cache time        scheduler_io->ltimer = tb_ltimer_init(TB_SCHEDULER_IO_LTIMER_GROW, TB_LTIMER_TICK_S, tb_true);        tb_assert_and_check_break(scheduler_io->ltimer);#endif        // start the io loop coroutine        if (!tb_lo_coroutine_start((tb_lo_scheduler_ref_t)scheduler, tb_lo_scheduler_io_loop, scheduler_io, tb_null)) break;        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit io scheduler        if (scheduler_io) tb_lo_scheduler_io_exit(scheduler_io);        scheduler_io = tb_null;    }    // ok?    return scheduler_io;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */static tb_bool_t tb_aiop_ptor_addo(tb_aicp_ptor_impl_t* ptor, tb_aico_impl_t* aico){    // check    tb_aiop_ptor_impl_t* impl = (tb_aiop_ptor_impl_t*)ptor;    tb_assert_and_check_return_val(impl && impl->aiop && aico, tb_false);                // the aiop aico    tb_aiop_aico_t* aiop_aico = (tb_aiop_aico_t*)aico;    // init impl    aiop_aico->impl = impl;    // done    tb_bool_t ok = tb_false;    switch (aico->type)    {    case TB_AICO_TYPE_SOCK:        {            // check            tb_assert_and_check_break(aico->handle);            // ok            ok = tb_true;        }        break;    case TB_AICO_TYPE_FILE:        {            // check            tb_assert_and_check_break(aico->handle);            // file: addo            ok = tb_aicp_file_addo(impl, aico);        }        break;    case TB_AICO_TYPE_TASK:        {            // ok            ok = tb_true;        }        break;    default:        break;    }    // ok?    return ok;}

/* ////////////////////////////////////////////////////////////////////////////////////// * interfaces */tb_dns_looker_ref_t tb_dns_looker_init(tb_char_t const* name){    // check    tb_assert_and_check_return_val(name, tb_null);    // must be not address    tb_assert(!tb_ipaddr_ip_cstr_set(tb_null, name, TB_IPADDR_FAMILY_NONE));    // done    tb_bool_t           ok = tb_false;    tb_dns_looker_t*    looker = tb_null;    do    {        // make looker        looker = tb_malloc0_type(tb_dns_looker_t);        tb_assert_and_check_return_val(looker, tb_null);        // dump server//      tb_dns_server_dump();        // get the dns server list        looker->maxn = tb_dns_server_get(looker->list);        tb_check_break(looker->maxn && looker->maxn <= tb_arrayn(looker->list));        // init name        if (!tb_static_string_init(&looker->name, (tb_char_t*)looker->data, TB_DNS_NAME_MAXN)) break;        tb_static_string_cstrcpy(&looker->name, name);        // init rpkt        if (!tb_static_buffer_init(&looker->rpkt, looker->data + TB_DNS_NAME_MAXN, TB_DNS_RPKT_MAXN)) break;        // init family        looker->family = TB_IPADDR_FAMILY_IPV4;        // init sock        looker->sock = tb_socket_init(TB_SOCKET_TYPE_UDP, looker->family);        tb_assert_and_check_break(looker->sock);        // init itor        looker->itor = 1;        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (looker) tb_dns_looker_exit((tb_dns_looker_ref_t)looker);        looker = tb_null;    }    // ok?    return (tb_dns_looker_ref_t)looker;}

tb_pointer_t tb_small_pool_nalloc0_(tb_small_pool_ref_t pool, tb_size_t item, tb_size_t size __tb_debug_decl__){    // check    tb_small_pool_impl_t* impl = (tb_small_pool_impl_t*)pool;    tb_assert_and_check_return_val(impl && impl->large_pool && size, tb_null);    tb_assert_and_check_return_val(item * size <= TB_SMALL_POOL_DATA_SIZE_MAXN, tb_null);    // disable small pool for debug#ifdef TB_SMALL_POOL_DISABLE    return tb_large_pool_nalloc0(impl->large_pool, item, size, tb_null);#endif    // done    tb_pointer_t data = tb_null;    do    {        // the fixed pool        tb_fixed_pool_ref_t fixed_pool = tb_small_pool_find_fixed(impl, item * size);        tb_assert_and_check_break(fixed_pool);        // done        data = tb_fixed_pool_malloc0_(fixed_pool __tb_debug_args__);        tb_assert_and_check_break(data);        // the data head        tb_pool_data_head_t* data_head = &(((tb_pool_data_head_t*)data)[-1]);        tb_assert_abort(data_head->debug.magic == TB_POOL_DATA_MAGIC);#ifdef __tb_debug__        // fill the patch bytes        if (data_head->size > (item * size)) tb_memset_((tb_byte_t*)data + (item * size), TB_POOL_DATA_PATCH, data_head->size - (item * size));#endif        // update size        data_head->size = item * size;     } while (0);    // check    tb_assertf_abort(data, "nalloc(%lu, %lu) failed!", item, size);    // ok?    return data;}

tb_bool_t tb_aico_open_sock_from_type(tb_aico_ref_t aico, tb_size_t type){    // check    tb_aico_impl_t* impl = (tb_aico_impl_t*)aico;    tb_aicp_impl_t* aicp_impl = (tb_aicp_impl_t*)impl->aicp;    tb_assert_and_check_return_val(impl && aicp_impl && aicp_impl->ptor && aicp_impl->ptor->addo, tb_false);    // done    tb_bool_t       ok = tb_false;    tb_socket_ref_t sock = tb_null;    do    {        // closed?        tb_assert_and_check_break(tb_atomic_get(&impl->state) == TB_STATE_CLOSED);        tb_assert_and_check_break(!impl->type && !impl->handle);        // init sock        sock = tb_socket_init(type);        tb_assert_and_check_break(sock);        // bind type and handle        impl->type     = TB_AICO_TYPE_SOCK;        impl->handle   = (tb_handle_t)sock;        // addo aico        ok = aicp_impl->ptor->addo(aicp_impl->ptor, impl);        tb_assert_and_check_break(ok);        // opened        tb_atomic_set(&impl->state, TB_STATE_OPENED);    } while (0);    // failed?    if (!ok)    {        // exit it        if (sock) tb_socket_exit(sock);        sock = tb_null;    }    // ok?    return ok;}

tb_bool_t tb_aico_open_file_from_path(tb_aico_ref_t aico, tb_char_t const* path, tb_size_t mode){    // check    tb_aico_impl_t* impl = (tb_aico_impl_t*)aico;    tb_aicp_impl_t* aicp_impl = (tb_aicp_impl_t*)impl->aicp;    tb_assert_and_check_return_val(impl && path && aicp_impl && aicp_impl->ptor && aicp_impl->ptor->addo, tb_false);    // done    tb_bool_t       ok = tb_false;    tb_file_ref_t   file = tb_null;    do    {        // closed?        tb_assert_and_check_break(tb_atomic_get(&impl->state) == TB_STATE_CLOSED);        tb_assert_and_check_break(!impl->type && !impl->handle);        // init file        file = tb_file_init(path, mode | TB_FILE_MODE_ASIO);        tb_assert_and_check_break(file);        // bind type and handle        impl->type     = TB_AICO_TYPE_FILE;        impl->handle   = (tb_handle_t)file;        // addo aico        ok = aicp_impl->ptor->addo(aicp_impl->ptor, impl);        tb_assert_and_check_break(ok);        // opened        tb_atomic_set(&impl->state, TB_STATE_OPENED);    } while (0);    // failed?    if (!ok)    {        // exit it        if (file) tb_file_exit(file);        file = tb_null;    }    // ok?    return ok;}

static tb_aiop_rtor_impl_t* tb_aiop_rtor_epoll_init(tb_aiop_impl_t* aiop){    // check    tb_assert_and_check_return_val(aiop && aiop->maxn, tb_null);    // done    tb_bool_t                   ok = tb_false;    tb_aiop_rtor_epoll_impl_t*  impl = tb_null;    do    {        // make impl        impl = tb_malloc0_type(tb_aiop_rtor_epoll_impl_t);        tb_assert_and_check_break(impl);        // init base        impl->base.aiop = aiop;        impl->base.code = TB_AIOE_CODE_EALL | TB_AIOE_CODE_CLEAR | TB_AIOE_CODE_ONESHOT;        impl->base.exit = tb_aiop_rtor_epoll_exit;        impl->base.cler = tb_aiop_rtor_epoll_cler;        impl->base.addo = tb_aiop_rtor_epoll_addo;        impl->base.delo = tb_aiop_rtor_epoll_delo;        impl->base.post = tb_aiop_rtor_epoll_post;        impl->base.wait = tb_aiop_rtor_epoll_wait;        // init epoll        impl->epfd = epoll_create(aiop->maxn);        tb_assert_and_check_break(impl->epfd > 0);        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (impl) tb_aiop_rtor_epoll_exit((tb_aiop_rtor_impl_t*)impl);        impl = tb_null;    }    // ok?    return (tb_aiop_rtor_impl_t*)impl;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */gb_mesh_face_list_ref_t gb_mesh_face_list_init(tb_element_t element){    // check    tb_assert_and_check_return_val(element.data && element.dupl && element.repl, tb_null);    // done    tb_bool_t                   ok = tb_false;    gb_mesh_face_list_impl_t*   impl = tb_null;    do    {        // make list        impl = tb_malloc0_type(gb_mesh_face_list_impl_t);        tb_assert_and_check_break(impl);        // init element        impl->element = element;        // init pool, item = face + data        impl->pool = tb_fixed_pool_init(tb_null, GB_MESH_FACE_LIST_GROW, sizeof(gb_mesh_face_t) + element.size, tb_null, gb_mesh_face_exit, (tb_cpointer_t)impl);        tb_assert_and_check_break(impl->pool);        // init head        tb_list_entry_init_(&impl->head, 0, sizeof(gb_mesh_face_t) + element.size, tb_null);        // init order        impl->order = GB_MESH_ORDER_INSERT_TAIL;        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit it        if (impl) gb_mesh_face_list_exit((gb_mesh_face_list_ref_t)impl);        impl = tb_null;    }    // ok?    return (gb_mesh_face_list_ref_t)impl;}