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

APR_DECLARE(apr_status_t) apr_pollset_remove(apr_pollset_t *pollset,                                             const apr_pollfd_t *descriptor){    apr_os_sock_t fd;    pfd_elem_t *ep;    apr_status_t rv = APR_SUCCESS;    int res;    pollset_lock_rings();    if (descriptor->desc_type == APR_POLL_SOCKET) {        fd = descriptor->desc.s->socketdes;    }    else {        fd = descriptor->desc.f->filedes;    }    res = port_dissociate(pollset->port_fd, PORT_SOURCE_FD, fd);    if (res < 0) {        rv = APR_NOTFOUND;    }    if (!APR_RING_EMPTY(&(pollset->query_ring), pfd_elem_t, link)) {        for (ep = APR_RING_FIRST(&(pollset->query_ring));             ep != APR_RING_SENTINEL(&(pollset->query_ring),                                     pfd_elem_t, link);             ep = APR_RING_NEXT(ep, link)) {            if (descriptor->desc.s == ep->pfd.desc.s) {                APR_RING_REMOVE(ep, link);                APR_RING_INSERT_TAIL(&(pollset->dead_ring),                                     ep, pfd_elem_t, link);                break;            }        }    }    if (!APR_RING_EMPTY(&(pollset->add_ring), pfd_elem_t, link)) {        for (ep = APR_RING_FIRST(&(pollset->add_ring));             ep != APR_RING_SENTINEL(&(pollset->add_ring),                                     pfd_elem_t, link);             ep = APR_RING_NEXT(ep, link)) {            if (descriptor->desc.s == ep->pfd.desc.s) {                APR_RING_REMOVE(ep, link);                APR_RING_INSERT_TAIL(&(pollset->dead_ring),                                     ep, pfd_elem_t, link);                break;            }        }    }    pollset_unlock_rings();    return rv;}

/* * NOTE: This function is not thread safe by itself. Caller should hold the lock */static apr_thread_pool_task_t *task_new(apr_thread_pool_t * me,                                        apr_thread_start_t func,                                        void *param, apr_byte_t priority,                                        void *owner, apr_time_t time){    apr_thread_pool_task_t *t;    if (APR_RING_EMPTY(me->recycled_tasks, apr_thread_pool_task, link)) {        t = apr_pcalloc(me->pool, sizeof(*t));        if (NULL == t) {            return NULL;        }    }    else {        t = APR_RING_FIRST(me->recycled_tasks);        APR_RING_REMOVE(t, link);    }    APR_RING_ELEM_INIT(t, link);    t->func = func;    t->param = param;    t->owner = owner;    if (time > 0) {        t->dispatch.time = apr_time_now() + time;    }    else {        t->dispatch.priority = priority;    }    return t;}

static apr_status_t mmap_cleanup(void *themmap){    apr_mmap_t *mm = themmap;    apr_mmap_t *next = APR_RING_NEXT(mm,link);    int rv = 0;    /* we no longer refer to the mmaped region */    APR_RING_REMOVE(mm,link);    APR_RING_NEXT(mm,link) = NULL;    APR_RING_PREV(mm,link) = NULL;    if (next != mm) {        /* more references exist, so we're done */        return APR_SUCCESS;    }#ifdef BEOS    rv = delete_area(mm->area);#else    rv = munmap(mm->mm, mm->size);#endif    mm->mm = (void *)-1;    if (rv == 0) {        return APR_SUCCESS;    }    return errno;}

static apr_status_t remove_tasks(apr_thread_pool_t *me, void *owner){    apr_thread_pool_task_t *t_loc;    apr_thread_pool_task_t *next;    int seg;    t_loc = APR_RING_FIRST(me->tasks);    while (t_loc != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link)) {        next = APR_RING_NEXT(t_loc, link);        if (t_loc->owner == owner) {            --me->task_cnt;            seg = TASK_PRIORITY_SEG(t_loc);            if (t_loc == me->task_idx[seg]) {                me->task_idx[seg] = APR_RING_NEXT(t_loc, link);                if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,                                                           apr_thread_pool_task,                                                           link)                    || TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {                    me->task_idx[seg] = NULL;                }            }            APR_RING_REMOVE(t_loc, link);        }        t_loc = next;    }    return APR_SUCCESS;}

/** Close connection */static apt_bool_t rtsp_server_connection_close(rtsp_server_t *server, rtsp_server_connection_t *rtsp_connection){	apr_size_t remaining_sessions = 0;	if(!rtsp_connection || !rtsp_connection->sock) {		return FALSE;	}	apt_log(RTSP_LOG_MARK,APT_PRIO_INFO,"Close RTSP Connection %s",rtsp_connection->id);	apt_poller_task_descriptor_remove(server->task,&rtsp_connection->sock_pfd);	apr_socket_close(rtsp_connection->sock);	rtsp_connection->sock = NULL;	APR_RING_REMOVE(rtsp_connection,link);	remaining_sessions = apr_hash_count(rtsp_connection->session_table);	if(remaining_sessions) {		rtsp_server_session_t *session;		void *val;		apr_hash_index_t *it;		apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Terminate Remaining RTSP Sessions [%"APR_SIZE_T_FMT"]",			remaining_sessions);		it = apr_hash_first(rtsp_connection->pool,rtsp_connection->session_table);		for(; it; it = apr_hash_next(it)) {			apr_hash_this(it,NULL,NULL,&val);			session = val;			if(session && session->terminating == FALSE) {				rtsp_server_session_terminate_request(server,session);			}		}	}	else {		rtsp_server_connection_destroy(rtsp_connection);	}	return TRUE;}

/** * Grab a resource from the front of the resource list. * Assumes: that the reslist is locked. */static apr_res_t *pop_resource(apr_reslist_t *reslist){    apr_res_t *res;    res = APR_RING_FIRST(&reslist->avail_list);    APR_RING_REMOVE(res, link);    reslist->nidle--;    return res;}

static void end_gen(mpm_gen_info_t *gi){    ap_log_error(APLOG_MARK, APLOG_TRACE4, 0, ap_server_conf,                 "end of generation %d", gi->gen);    ap_run_end_generation(ap_server_conf, gi->gen);    APR_RING_REMOVE(gi, link);    APR_RING_INSERT_HEAD(unused_geninfo, gi, mpm_gen_info_t, link);}

static apr_status_t do_wait(apr_thread_cond_t *cond, apr_thread_mutex_t *mutex,                            apr_interval_time_t timeout){    struct waiter_t *wait;    thread_id cth = find_thread(NULL);    apr_status_t rv;    int flags = B_RELATIVE_TIMEOUT;        /* We must be the owner of the mutex or we can't do this... */        if (mutex->owner != cth) {        /* What should we return??? */        return APR_EINVAL;    }    acquire_sem(cond->lock);    wait = APR_RING_FIRST(&cond->flist);    if (wait)        APR_RING_REMOVE(wait, link);    else        wait = make_waiter(cond->pool);       APR_RING_INSERT_TAIL(&cond->alist, wait, waiter_t, link);    cond->condlock = mutex;    release_sem(cond->lock);           apr_thread_mutex_unlock(cond->condlock);    if (timeout == 0)        flags = 0;            rv = acquire_sem_etc(wait->sem, 1, flags, timeout);    apr_thread_mutex_lock(cond->condlock);        if (rv != B_OK) {        if (rv == B_TIMED_OUT)            return APR_TIMEUP;        return rv;           }    acquire_sem(cond->lock);    APR_RING_REMOVE(wait, link);    APR_RING_INSERT_TAIL(&cond->flist, wait, waiter_t, link);    release_sem(cond->lock);        return APR_SUCCESS;}

APT_DECLARE(apt_list_elem_t*) apt_list_elem_remove(apt_obj_list_t *list, apt_list_elem_t *elem){	apt_list_elem_t *next_elem = APR_RING_NEXT(elem,link);	APR_RING_REMOVE(elem,link);	if(next_elem == APR_RING_SENTINEL(&list->head,apt_list_elem_t,link)) {		next_elem = NULL;	}	return next_elem;}

static APR_INLINE mpf_chunk_t* mpf_buffer_chunk_read(mpf_buffer_t *buffer){	mpf_chunk_t *chunk = NULL;	if(!APR_RING_EMPTY(&buffer->head,mpf_chunk_t,link)) {		chunk = APR_RING_FIRST(&buffer->head);		APR_RING_REMOVE(chunk,link);	}	return chunk;}

MPF_DECLARE(void) mpf_context_factory_destroy(mpf_context_factory_t *factory){	mpf_context_t *context;	while(!APR_RING_EMPTY(&factory->head, mpf_context_t, link)) {		context = APR_RING_FIRST(&factory->head);		mpf_context_destroy(context);		APR_RING_REMOVE(context, link);	}}

/* Destroy RTSP connection */static apt_bool_t rtsp_client_connection_destroy(rtsp_client_connection_t *rtsp_connection){	rtsp_client_t *client = rtsp_connection->client;	APR_RING_REMOVE(rtsp_connection,link);	rtsp_client_connection_close(client,rtsp_connection);	apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Destroy RTSP Connection %s",rtsp_connection->id);	apr_pool_destroy(rtsp_connection->pool);	return TRUE;}

/** * Retrieves the next available socket from the queue. If there are no * sockets available, it will block until one becomes available. * Once retrieved, the socket is placed into the address specified by * 'sd'. */apr_status_t ap_queue_pop_something(fd_queue_t * queue, apr_socket_t ** sd,                                    event_conn_state_t ** ecs, apr_pool_t ** p,                                    timer_event_t ** te_out){    fd_queue_elem_t *elem;    apr_status_t rv;    if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {        return rv;    }    /* Keep waiting until we wake up and find that the queue is not empty. */    if (ap_queue_empty(queue)) {        if (!queue->terminated) {            apr_thread_cond_wait(queue->not_empty, queue->one_big_mutex);        }        /* If we wake up and it's still empty, then we were interrupted */        if (ap_queue_empty(queue)) {            rv = apr_thread_mutex_unlock(queue->one_big_mutex);            if (rv != APR_SUCCESS) {                return rv;            }            if (queue->terminated) {                return APR_EOF; /* no more elements ever again */            }            else {                return APR_EINTR;            }        }    }    *te_out = NULL;    if (!APR_RING_EMPTY(&queue->timers, timer_event_t, link)) {        *te_out = APR_RING_FIRST(&queue->timers);        APR_RING_REMOVE(*te_out, link);    }    else {        elem = &queue->data[queue->out];        queue->out++;        if (queue->out >= queue->bounds)            queue->out -= queue->bounds;        queue->nelts--;        *sd = elem->sd;        *ecs = elem->ecs;        *p = elem->p;#ifdef AP_DEBUG        elem->sd = NULL;        elem->p = NULL;#endif /* AP_DEBUG */    }    rv = apr_thread_mutex_unlock(queue->one_big_mutex);    return rv;}

static apr_status_t impl_pollset_add(apr_pollset_t *pollset,                                     const apr_pollfd_t *descriptor){    apr_os_sock_t fd;    pfd_elem_t *elem;    apr_status_t rv = APR_SUCCESS;    pollset_lock_rings();    if (!APR_RING_EMPTY(&(pollset->p->free_ring), pfd_elem_t, link)) {        elem = APR_RING_FIRST(&(pollset->p->free_ring));        APR_RING_REMOVE(elem, link);    }    else {        elem = (pfd_elem_t *) apr_palloc(pollset->pool, sizeof(pfd_elem_t));        APR_RING_ELEM_INIT(elem, link);    }    elem->pfd = *descriptor;    if (descriptor->desc_type == APR_POLL_SOCKET) {        fd = descriptor->desc.s->socketdes;    }    else {        fd = descriptor->desc.f->filedes;    }    if (descriptor->reqevents & APR_POLLIN) {        EV_SET(&pollset->p->kevent, fd, EVFILT_READ, EV_ADD, 0, 0, elem);        if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0,                   NULL) == -1) {            rv = apr_get_netos_error();        }    }    if (descriptor->reqevents & APR_POLLOUT && rv == APR_SUCCESS) {        EV_SET(&pollset->p->kevent, fd, EVFILT_WRITE, EV_ADD, 0, 0, elem);        if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0,                   NULL) == -1) {            rv = apr_get_netos_error();        }    }    if (rv == APR_SUCCESS) {        APR_RING_INSERT_TAIL(&(pollset->p->query_ring), elem, pfd_elem_t, link);    }    else {        APR_RING_INSERT_TAIL(&(pollset->p->free_ring), elem, pfd_elem_t, link);    }    pollset_unlock_rings();    return rv;}

/** * Get an empty resource container from the free list. */static apr_res_t *get_container(apr_reslist_t *reslist){    apr_res_t *res;    assert(!APR_RING_EMPTY(&reslist->free_list, apr_res_t, link));    res = APR_RING_FIRST(&reslist->free_list);    APR_RING_REMOVE(res, link);    return res;}

static apt_bool_t apt_timer_remove(apt_timer_queue_t *timer_queue, apt_timer_t *timer){	/* remove node (timer) from the list */	APR_RING_REMOVE(timer,link);	timer->scheduled_time = 0;	if(APR_RING_EMPTY(&timer_queue->head, apt_timer_t, link)) {		/* reset elapsed time if no timers set */		timer_queue->elapsed_time = 0;	}	return TRUE;}

static apr_status_t impl_pollset_remove(apr_pollset_t *pollset,                                        const apr_pollfd_t *descriptor){    pfd_elem_t *ep;    apr_status_t rv = APR_SUCCESS;#ifdef HAVE_MTCP	struct mtcp_epoll_event ev = {0};#else	struct epoll_event ev = {0}; /* ignored, but must be passed with                                  * kernel < 2.6.9                                  */#endif	int ret = -1;    if (descriptor->desc_type == APR_POLL_SOCKET) {#ifdef HAVE_MTCP		int cpu = sched_getcpu();		ret = mtcp_epoll_ctl(g_mctx[cpu], pollset->p->epoll_fd, EPOLL_CTL_DEL,                        descriptor->desc.s->socketdes, &ev);#else 		ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_DEL,				descriptor->desc.s->socketdes, &ev);#endif    }    else {        ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_DEL,                        descriptor->desc.f->filedes, &ev);    }    if (ret < 0) {        rv = APR_NOTFOUND;    }    if (!(pollset->flags & APR_POLLSET_NOCOPY)) {        pollset_lock_rings();        for (ep = APR_RING_FIRST(&(pollset->p->query_ring));             ep != APR_RING_SENTINEL(&(pollset->p->query_ring),                                     pfd_elem_t, link);             ep = APR_RING_NEXT(ep, link)) {                            if (descriptor->desc.s == ep->pfd.desc.s) {                APR_RING_REMOVE(ep, link);                APR_RING_INSERT_TAIL(&(pollset->p->dead_ring),                                     ep, pfd_elem_t, link);                break;            }        }        pollset_unlock_rings();    }    return rv;}

/* * NOTE: This function is not thread safe by itself. Caller should hold the lock */static apr_thread_pool_task_t *pop_task(apr_thread_pool_t * me){    apr_thread_pool_task_t *task = NULL;    int seg;    /* check for scheduled tasks */    if (me->scheduled_task_cnt > 0) {        task = APR_RING_FIRST(me->scheduled_tasks);        assert(task != NULL);        assert(task !=               APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,                                 link));        /* if it's time */        if (task->dispatch.time <= apr_time_now()) {            --me->scheduled_task_cnt;            APR_RING_REMOVE(task, link);            return task;        }    }    /* check for normal tasks if we're not returning a scheduled task */    if (me->task_cnt == 0) {        return NULL;    }    task = APR_RING_FIRST(me->tasks);    assert(task != NULL);    assert(task != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link));    --me->task_cnt;    seg = TASK_PRIORITY_SEG(task);    if (task == me->task_idx[seg]) {        me->task_idx[seg] = APR_RING_NEXT(task, link);        if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,                                                   apr_thread_pool_task, link)            || TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {            me->task_idx[seg] = NULL;        }    }    APR_RING_REMOVE(task, link);    return task;}

static apr_status_t impl_pollset_add(apr_pollset_t *pollset,                                     const apr_pollfd_t *descriptor){    apr_os_sock_t fd;    pfd_elem_t *elem;    int res;    apr_status_t rv = APR_SUCCESS;    pollset_lock_rings();    if (!APR_RING_EMPTY(&(pollset->p->free_ring), pfd_elem_t, link)) {        elem = APR_RING_FIRST(&(pollset->p->free_ring));        APR_RING_REMOVE(elem, link);    }    else {        elem = (pfd_elem_t *) apr_palloc(pollset->pool, sizeof(pfd_elem_t));        APR_RING_ELEM_INIT(elem, link);        elem->on_query_ring = 0;    }    elem->pfd = *descriptor;    if (descriptor->desc_type == APR_POLL_SOCKET) {        fd = descriptor->desc.s->socketdes;    }    else {        fd = descriptor->desc.f->filedes;    }    /* If another thread is polling, notify the kernel immediately; otherwise,     * wait until the next call to apr_pollset_poll().     */    if (apr_atomic_read32(&pollset->p->waiting)) {        res = port_associate(pollset->p->port_fd, PORT_SOURCE_FD, fd,                              get_event(descriptor->reqevents), (void *)elem);        if (res < 0) {            rv = apr_get_netos_error();            APR_RING_INSERT_TAIL(&(pollset->p->free_ring), elem, pfd_elem_t, link);        }        else {            elem->on_query_ring = 1;            APR_RING_INSERT_TAIL(&(pollset->p->query_ring), elem, pfd_elem_t, link);        }    }     else {        APR_RING_INSERT_TAIL(&(pollset->p->add_ring), elem, pfd_elem_t, link);    }    pollset_unlock_rings();    return rv;}

static apr_status_t impl_pollset_add(apr_pollset_t *pollset,                                     const apr_pollfd_t *descriptor){    struct epoll_event ev = {0};    int ret = -1;    pfd_elem_t *elem = NULL;    apr_status_t rv = APR_SUCCESS;    ev.events = get_epoll_event(descriptor->reqevents);    if (pollset->flags & APR_POLLSET_NOCOPY) {        ev.data.ptr = (void *)descriptor;    }    else {        pollset_lock_rings();        if (!APR_RING_EMPTY(&(pollset->p->free_ring), pfd_elem_t, link)) {            elem = APR_RING_FIRST(&(pollset->p->free_ring));            APR_RING_REMOVE(elem, link);        }        else {            elem = (pfd_elem_t *) apr_palloc(pollset->pool, sizeof(pfd_elem_t));            APR_RING_ELEM_INIT(elem, link);        }        elem->pfd = *descriptor;        ev.data.ptr = elem;    }    if (descriptor->desc_type == APR_POLL_SOCKET) {        ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_ADD,                        descriptor->desc.s->socketdes, &ev);    }    else {        ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_ADD,                        descriptor->desc.f->filedes, &ev);    }    if (0 != ret) {        rv = apr_get_netos_error();    }    if (!(pollset->flags & APR_POLLSET_NOCOPY)) {        if (rv != APR_SUCCESS) {            APR_RING_INSERT_TAIL(&(pollset->p->free_ring), elem, pfd_elem_t, link);        }        else {            APR_RING_INSERT_TAIL(&(pollset->p->query_ring), elem, pfd_elem_t, link);        }        pollset_unlock_rings();    }    return rv;}

static apr_status_t impl_pollset_remove(apr_pollset_t *pollset,                                        const apr_pollfd_t *descriptor){    pfd_elem_t *ep;    apr_status_t rv;    apr_os_sock_t fd;    pollset_lock_rings();    if (descriptor->desc_type == APR_POLL_SOCKET) {        fd = descriptor->desc.s->socketdes;    }    else {        fd = descriptor->desc.f->filedes;    }    rv = APR_NOTFOUND; /* unless at least one of the specified conditions is */    if (descriptor->reqevents & APR_POLLIN) {        EV_SET(&pollset->p->kevent, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);        if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0,                   NULL) != -1) {            rv = APR_SUCCESS;        }    }    if (descriptor->reqevents & APR_POLLOUT) {        EV_SET(&pollset->p->kevent, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);        if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0,                   NULL) != -1) {            rv = APR_SUCCESS;        }    }    for (ep = APR_RING_FIRST(&(pollset->p->query_ring));         ep != APR_RING_SENTINEL(&(pollset->p->query_ring),                                 pfd_elem_t, link);         ep = APR_RING_NEXT(ep, link)) {        if (descriptor->desc.s == ep->pfd.desc.s) {            APR_RING_REMOVE(ep, link);            APR_RING_INSERT_TAIL(&(pollset->p->dead_ring),                                 ep, pfd_elem_t, link);            break;        }    }    pollset_unlock_rings();    return rv;}

static apt_bool_t mrcp_client_agent_connection_remove(mrcp_connection_agent_t *agent, mrcp_connection_t *connection){	/* remove from the list */	APR_RING_REMOVE(connection,link);	if(connection->sock) {		apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Close TCP/MRCPv2 Connection %s",connection->id);		apt_poller_task_descriptor_remove(agent->task,&connection->sock_pfd);		apr_socket_close(connection->sock);		connection->sock = NULL;	}	return TRUE;}

APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond){    struct waiter_t *wake;        acquire_sem(cond->lock);    while (! APR_RING_EMPTY(&cond->alist, waiter_t, link)) {        wake = APR_RING_FIRST(&cond->alist);        APR_RING_REMOVE(wake, link);        release_sem(wake->sem);        APR_RING_INSERT_TAIL(&cond->flist, wake, waiter_t, link);    }    release_sem(cond->lock);        return APR_SUCCESS;}

static apr_status_t remove_scheduled_tasks(apr_thread_pool_t *me,                                           void *owner){    apr_thread_pool_task_t *t_loc;    apr_thread_pool_task_t *next;    t_loc = APR_RING_FIRST(me->scheduled_tasks);    while (t_loc !=           APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,                             link)) {        next = APR_RING_NEXT(t_loc, link);        /* if this is the owner remove it */        if (t_loc->owner == owner) {            --me->scheduled_task_cnt;            APR_RING_REMOVE(t_loc, link);        }        t_loc = next;    }    return APR_SUCCESS;}

/** Kill timer */APT_DECLARE(apt_bool_t) apt_timer_kill(apt_timer_t *timer){    apt_timer_queue_t *queue = timer->queue;    if(!timer->scheduled_time) {        return FALSE;    }#ifdef APT_TIMER_DEBUG    apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Kill Timer 0x%x [%u]",timer,timer->scheduled_time);#endif    /* remove node (timer) from the list */    APR_RING_REMOVE(timer,link);    timer->scheduled_time = 0;    if(APR_RING_EMPTY(&queue->head, apt_timer_t, link)) {        /* reset elapsed time if no timers set */        queue->elapsed_time = 0;    }    return TRUE;}