/**
* 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);
}