int fdset_poll2(fdset *fds) {
int r, i;
while (1) {
FD_ZERO(&fds->rfds);
FD_ZERO(&fds->exfds);
FD_ZERO(&fds->wfds);
fds->max_fd = -1;
if (vector_empty(&fds->rev) && vector_empty(&fds->exev)) {
// We have nothing left to select(2) on.
return 0;
}
fdset_populate(fds, &fds->rfds, &fds->rev);
fdset_populate(fds, &fds->exfds, &fds->exev);
r = select(fds->max_fd+1, &fds->rfds, 0, &fds->exfds, &fds->timeout);
if (r < 0) {
if (errno != EINTR) {
perror("select");
return r;
}
continue;
}
if (r == 0) {
// Timeout case
fds->timeout_cb(NULL);
continue;
}
for (i = 0; i < vector_size(&fds->rev); ++i) {
select_event_t *pse = (select_event_t*)vector_at(&fds->rev, i);
if (FD_ISSET(pse->fd, &fds->rfds)) {
VERBOSE("FD %d is read ready\n", pse->fd);
pse->callback(pse->opaque);
}
}
for (i = 0; i < vector_size(&fds->exev); ++i) {
int rev_pos;
select_event_t se;
se = *(select_event_t*)vector_at(&fds->exev, i);
if (FD_ISSET(se.fd, &fds->exfds)) {
INFO("FD %d is in ERROR\n", se.fd);
// Also remove this fd from the list of ex/read events
// to monitor.
vector_erase(&fds->exev, i);
--i;
// Remove from read events list as well.
rev_pos = algorithm_find(&fds->rev, &se.fd, find_by_fd);
if (rev_pos != -1) {
vector_erase(&fds->rev, rev_pos);
}
se.callback(se.opaque);
} // if ()
} // for ()
} // while (1)
} // fdset_poll2()
void test_empty() {
vector* v = create_test_vector();
printf("Is v empty? %d\n", vector_empty(v));
vector* empty = vector_new();
printf("Is empty empty? %d\n", vector_empty(empty));
}
/**
* Access last vector data.
*/
void* vector_back(const vector_t* cpvec_vector)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
assert(!vector_empty(cpvec_vector));
return vector_at(cpvec_vector, vector_size(cpvec_vector) - 1);
}
/**
* Access first vector data.
*/
void* vector_front(const vector_t* cpvec_vector)
{
assert(cpvec_vector != NULL);
assert(_vector_is_inited(cpvec_vector));
assert(!vector_empty(cpvec_vector));
return vector_at(cpvec_vector, 0);
}
vector* get_all_interfaces(void) {
if (!vector_empty(&interfaces)) {
return &interfaces;
}
struct ifi_info *ifi, *ifi_head = Get_ifi_info_plus(AF_INET, 0);
for (ifi = ifi_head; ifi != NULL; ifi = ifi->ifi_next) {
vector_push_back(&interfaces, ifi);
}
return &interfaces;
}
/**
* Tests if a stack is empty.
*/
bool_t stack_empty(const cstl_stack_t* cpsk_stack)
{
assert(cpsk_stack != NULL);
#if defined (CSTL_STACK_VECTOR_SEQUENCE)
return vector_empty(&cpsk_stack->_t_sequence);
#elif defined (CSTL_STACK_LIST_SEQUENCE)
return list_empty(&cpsk_stack->_t_sequence);
#else
return deque_empty(&cpsk_stack->_t_sequence);
#endif
}
/**
* Delete the element at the end of vector.
*/
void vector_pop_back(vector_t* pvec_vector)
{
bool_t b_result = false;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
assert(!vector_empty(pvec_vector));
/* destroy last element */
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_DESTROY_FUNCTION(pvec_vector)(pvec_vector->_pby_finish - _GET_VECTOR_TYPE_SIZE(pvec_vector), &b_result);
assert(b_result);
pvec_vector->_pby_finish -= _GET_VECTOR_TYPE_SIZE(pvec_vector);
}
int
main(int argc, char *argv[]) {
vector_t *vector = vector_alloc(data_free_func);
if (vector == NULL) {
log_error("Failed to alloc vector");
return RET_FAILED;
}
for (int i = 0; i < TEST_NUM; i ++) {
data_t *data = my_malloc(sizeof(data_t));
data->num = i;
vector_unshift(vector, data);
for (int j = 0; j <= i; j ++) {
data_t *unshift = vector_get(vector, j);
test(vector_get, i - j, unshift->num);
}
}
for (int i = 0; i < TEST_NUM; i ++) {
data_t *data = vector_pop(vector);
test(vector_pop, i, data->num);
data_free_func(data);
}
vector_empty(vector);
for (int i = 0; i < TEST_NUM; i ++) {
data_t *data = my_malloc(sizeof(data_t));
data->num = i;
if (i & 0x1) {
vector_unshift(vector, data);
} else {
vector_push_back(vector, data);
}
}
for (int i = 0; i < TEST_NUM / 2; i ++) {
data_t *data = vector_shift(vector);
test(vector_shift, TEST_NUM - 2 * i - 1, data->num);
data_free_func(data);
}
for (int i = 0; i < TEST_NUM / 2; i ++) {
data_t *data = vector_shift(vector);
test(vector_shift, 2 * i, data->num);
data_free_func(data);
}
vector_empty(vector);
for (int i = 0; i < TEST_NUM; i ++) {
data_t *data = my_malloc(sizeof(data_t));
data->num = i;
vector_push_back(vector, data);
}
for (int i = 0; i < vector_size(vector); i ++) {
data_t *data = vector_get(vector, i);
test(vector_get, i, data->num);
}
vector_destroy(vector);
}
int stack_empty(Stack* stack)
{
return vector_empty(stack->elems);
}
bool_t priority_queue_empty(const priority_queue_t* cpt_pqueue)
{
assert(cpt_pqueue != NULL);
return vector_empty(&cpt_pqueue->_t_vector);
}
int stack_empty(const stack *s)
{
return vector_empty(&s->storage);
}
