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