/** * Transfer the range [it_begin, it_end) to position it_pos+1. */ void _slist_transfer_after(slist_iterator_t it_pos, slist_iterator_t it_begin, slist_iterator_t it_end) { assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_pos), it_pos)); assert(!iterator_equal(it_pos, slist_end(_SLIST_ITERATOR_CONTAINER(it_pos)))); assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_begin), it_begin)); assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_end), it_end)); assert(_SLIST_ITERATOR_CONTAINER(it_begin) == _SLIST_ITERATOR_CONTAINER(it_end)); assert(iterator_equal(it_begin, it_end) || _slist_iterator_before(it_begin, it_end)); assert(_slist_same_slist_iterator_type(_SLIST_ITERATOR_CONTAINER(it_pos), it_begin)); /* empty range */ if(iterator_equal(it_begin, it_end)) { return; } /* same slist container */ if(_SLIST_ITERATOR_CONTAINER(it_pos) == _SLIST_ITERATOR_CONTAINER(it_begin)) { iterator_t it_iter = iterator_next(it_pos); assert(iterator_equal(it_iter, it_begin) || iterator_equal(it_iter, it_end) || _slist_iterator_before(it_iter, it_begin) || _slist_iterator_before(it_end, it_iter)); if(iterator_equal(it_iter, it_begin) || iterator_equal(it_iter, it_end)) { return; } } slist_insert_after_range(_SLIST_ITERATOR_CONTAINER(it_pos), it_pos, it_begin, it_end); slist_erase_range(_SLIST_ITERATOR_CONTAINER(it_begin), it_begin, it_end); }
/** * Assign slist with variable argument of specificed element. */ void _slist_assign_elem_varg(slist_t* pslist_slist, size_t t_count, va_list val_elemlist) { slist_iterator_t it_iter; _slistnode_t* pt_varg = NULL; bool_t b_result = false; assert(pslist_slist != NULL); assert(_slist_is_inited(pslist_slist)); slist_resize(pslist_slist, t_count); /* get varg value */ pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); assert(pt_varg != NULL); _slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg); /* copy value from varg */ for (it_iter = slist_begin(pslist_slist); !iterator_equal(it_iter, slist_end(pslist_slist)); it_iter = iterator_next(it_iter)) { b_result = _GET_SLIST_TYPE_SIZE(pslist_slist); _GET_SLIST_TYPE_COPY_FUNCTION(pslist_slist)( ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, pt_varg->_pby_data, &b_result); assert(b_result); } /* destroy varg value */ _slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg); _alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); }
void shutDown(void) { char buffer[TEMP_BUF_SIZE]; #if defined(OS_WIN32) if (!GDI_shutdown(buffer, sizeof(buffer))) { s_log(0, buffer); } #endif { slist_iterator_t it = slist_begin(s_outputs); while (it != slist_end(s_outputs)) { struct output_descriptor* od = (struct output_descriptor*) slist_iter_deref(it); output_descriptor_free(od); slist_iter_advance(&it); } slist_free(s_outputs); // TODO: why is this commented out? /*#if defined (WITH_GL) if(!GL_shutdown(buffer, sizeof(buffer))) { s_log(0, buffer); } #endif*/ } }
/** * Remove element that specificed by variable argument slist from slist container. */ void _slist_remove_varg(slist_t* pslist_slist, va_list val_elemlist) { slist_iterator_t it_iter; /* for iterate */ _slistnode_t* pt_varg = NULL; bool_t b_less = false; bool_t b_greater = false; /* test the pointer is valid */ assert(pslist_slist != NULL); assert(_slist_is_inited(pslist_slist)); pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); assert(pt_varg != NULL); _slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg); it_iter = slist_begin(pslist_slist); while (!iterator_equal(it_iter, slist_end(pslist_slist))) { b_less = b_greater = _GET_SLIST_TYPE_SIZE(pslist_slist); _GET_SLIST_TYPE_LESS_FUNCTION(pslist_slist)( pt_varg->_pby_data, ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, &b_less); _GET_SLIST_TYPE_LESS_FUNCTION(pslist_slist)( ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, pt_varg->_pby_data, &b_greater); if (b_less || b_greater) { it_iter = iterator_next(it_iter); } else { it_iter = slist_erase(pslist_slist, it_iter); } } _slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg); _alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); }
/** * Get data value pointer referenced by iterator, but ignore char*. */ const void* _slist_iterator_get_pointer_ignore_cstr(slist_iterator_t it_iter) { assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_iter), it_iter)); assert(!iterator_equal(it_iter, slist_end(_SLIST_ITERATOR_CONTAINER(it_iter)))); return ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data; }
/** * Reset the size of slist elements, and filled element is from variable argument slist. */ void _slist_resize_elem_varg(slist_t* pslist_slist, size_t t_resize, va_list val_elemlist) { assert(pslist_slist != NULL); assert(_slist_is_inited(pslist_slist)); if (t_resize <= slist_size(pslist_slist)) { slist_iterator_t it_pos = iterator_advance(slist_begin(pslist_slist), t_resize); slist_erase_range(pslist_slist, it_pos, slist_end(pslist_slist)); } else { slist_iterator_t it_pos; _slistnode_t* pt_node = NULL; _slistnode_t* pt_varg = NULL; size_t t_size = slist_size(pslist_slist); size_t i = 0; bool_t b_result = false; if (!slist_empty(pslist_slist)) { it_pos = slist_previous(pslist_slist, slist_end(pslist_slist)); } else { _SLIST_ITERATOR_COREPOS(it_pos) = (_byte_t*)&pslist_slist->_t_head; } /* get varg value only once */ pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); assert(pt_varg != NULL); _slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg); for (i = 0; i < t_resize - t_size; ++i) { pt_node = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); assert(pt_node != NULL); _slist_init_node_auxiliary(pslist_slist, pt_node); /* copy value from varg */ b_result = _GET_SLIST_TYPE_SIZE(pslist_slist); _GET_SLIST_TYPE_COPY_FUNCTION(pslist_slist)(pt_node->_pby_data, pt_varg->_pby_data, &b_result); assert(b_result); pt_node->_pt_next = ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_pos))->_pt_next; ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_pos))->_pt_next = pt_node; pt_node = NULL; } _slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg); _alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); } }
/** * Return iterator reference next element. */ slist_iterator_t _slist_iterator_next(slist_iterator_t it_iter) { assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_iter), it_iter)); assert(!iterator_equal(it_iter, slist_end(_SLIST_ITERATOR_CONTAINER(it_iter)))); _SLIST_ITERATOR_COREPOS(it_iter) = (_byte_t*)(((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pt_next); return it_iter; }
void test__slist_iterator_next__invalid_iter_end(void** state) { slist_iterator_t it_iter; slist_t* pslist = create_slist(int); slist_init_elem(pslist, 10, 100); it_iter = slist_end(pslist); expect_assert_failure(_slist_iterator_next(it_iter)); slist_destroy(pslist); }
void test__slist_iterator_get_value__invalid_data_buffer(void** state) { slist_iterator_t it_iter; slist_t* pslist = create_slist(int); slist_init_elem(pslist, 10, 100); it_iter = slist_end(pslist); expect_assert_failure(_slist_iterator_get_value(it_iter, NULL)); slist_destroy(pslist); }
void test__slist_iterator_get_value__invalid_iterator_end(void** state) { int n_value = 0; slist_iterator_t it_iter; slist_t* pslist = create_slist(int); slist_init_elem(pslist, 10, 100); it_iter = slist_end(pslist); expect_assert_failure(_slist_iterator_get_value(it_iter, &n_value)); slist_destroy(pslist); }
void test__slist_iterator_next__successfully_end(void** state) { slist_iterator_t it_iter; slist_t* pslist = create_slist(int); slist_init_elem(pslist, 1, 100); it_iter = slist_begin(pslist); it_iter = _slist_iterator_next(it_iter); assert_true(iterator_equal(it_iter, slist_end(pslist))); slist_destroy(pslist); }
/** * Get data value pointer referenced by iterator. */ const void* _slist_iterator_get_pointer(slist_iterator_t it_iter) { assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_iter), it_iter)); assert(!iterator_equal(it_iter, slist_end(_SLIST_ITERATOR_CONTAINER(it_iter)))); /* char* */ if (strncmp(_GET_SLIST_TYPE_BASENAME(_SLIST_ITERATOR_CONTAINER(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) { return string_c_str((string_t*)((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data); } else { return ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data; } }
/** * Insert multiple copys of element after specificed position. */ void _slist_insert_after_n(slist_t* pslist_slist, slist_iterator_t it_pos, size_t t_count, ...) { va_list val_elemlist; assert(pslist_slist != NULL); assert(_slist_is_inited(pslist_slist)); assert(_slist_iterator_belong_to_slist(pslist_slist, it_pos)); assert(!iterator_equal(it_pos, slist_end(pslist_slist))); va_start(val_elemlist, t_count); _slist_insert_after_n_varg(pslist_slist, it_pos, t_count, val_elemlist); va_end(val_elemlist); }
/** * Insert one copy of element after specificed position. */ slist_iterator_t _slist_insert_after(slist_t* pslist_slist, slist_iterator_t it_pos, ...) { va_list val_elemlist; assert(pslist_slist != NULL); assert(_slist_is_inited(pslist_slist)); assert(_slist_iterator_belong_to_slist(pslist_slist, it_pos)); assert(!iterator_equal(it_pos, slist_end(pslist_slist))); va_start(val_elemlist, it_pos); _slist_insert_after_n_varg(pslist_slist, it_pos, 1, val_elemlist); va_end(val_elemlist); return iterator_next(it_pos); }
/** * Set data value referenced by iterator. */ void _slist_iterator_set_value(slist_iterator_t it_iter, const void* cpv_value) { assert(cpv_value != NULL); assert(_slist_iterator_belong_to_slist(_SLIST_ITERATOR_CONTAINER(it_iter), it_iter)); assert(!iterator_equal(it_iter, slist_end(_SLIST_ITERATOR_CONTAINER(it_iter)))); /* char* */ if (strncmp(_GET_SLIST_TYPE_BASENAME(_SLIST_ITERATOR_CONTAINER(it_iter)), _C_STRING_TYPE, _TYPE_NAME_SIZE) == 0) { string_assign_cstr((string_t*)((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, (char*)cpv_value); } else { bool_t b_result = _GET_SLIST_TYPE_SIZE(_SLIST_ITERATOR_CONTAINER(it_iter)); _GET_SLIST_TYPE_COPY_FUNCTION(_SLIST_ITERATOR_CONTAINER(it_iter))( ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_iter))->_pby_data, cpv_value, &b_result); assert(b_result); } }
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; }
void output_close(const char* driver_name, const char* server_name) { // find 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), "Trying to close invalid output: '%s:%s'", driver_name, server_name); s_log(0, buffer); return; } od = (struct output_descriptor*) slist_iter_deref(it); assert(od->ref_count >= 1); // delete drv and descriptor if necessary if (od->ref_count == 1) { struct OutputDriver* drv = od->drv; if (drv->inst != 0) { drv->destroy(drv->inst); drv->inst = 0; } free(drv); od->drv = 0; } // decrease refcount od->ref_count -= 1; }
/** * Insert multiple copys of element after specificed position. */ void _slist_insert_after_n_varg(slist_t* pslist_slist, slist_iterator_t it_pos, size_t t_count, va_list val_elemlist) { size_t i = 0; _slistnode_t* pt_node = NULL; _slistnode_t* pt_varg = NULL; bool_t b_result = false; assert(pslist_slist != NULL); assert(_slist_is_inited(pslist_slist)); assert(_slist_iterator_belong_to_slist(pslist_slist, it_pos)); assert(!iterator_equal(it_pos, slist_end(pslist_slist))); /* get varg value only once */ pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); assert(pt_varg != NULL); _slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg); for (i = 0; i < t_count; ++i) { /* allocate slist node */ pt_node = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); assert(pt_node != NULL); _slist_init_node_auxiliary(pslist_slist, pt_node); /* copy value from varg */ b_result = _GET_SLIST_TYPE_SIZE(pslist_slist); _GET_SLIST_TYPE_COPY_FUNCTION(pslist_slist)(pt_node->_pby_data, pt_varg->_pby_data, &b_result); assert(b_result); /* link the node to slist */ pt_node->_pt_next = ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_pos))->_pt_next; ((_slistnode_t*)_SLIST_ITERATOR_COREPOS(it_pos))->_pt_next = pt_node; pt_node = NULL; } /* destroy varg value */ _slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg); _alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1); }