epics::pvAccess::fair_queue< T > Class Template Reference

#include "fairQueue.h"

Classes
class	entry

Public Types
typedef std::tr1::shared_ptr< T >	value_type

Public Member Functions
	fair_queue ()
	~fair_queue ()
void	clear ()
bool	empty () const
void	push_back (const value_type &ent)
bool	pop_front_try (value_type &ret)
void	pop_front (value_type &ret)
bool	pop_front (value_type &ret, double timeout)

Detailed Description

template<typename T>
class epics::pvAccess::fair_queue< T >

Definition at line 59 of file fairQueue.h.

Member Typedef Documentation

template<typename T>

typedef std::tr1::shared_ptr<T> epics::pvAccess::fair_queue< T >::value_type

Definition at line 63 of file fairQueue.h.

Constructor & Destructor Documentation

template<typename T>

epics::pvAccess::fair_queue< T >::fair_queue ( )

inline

Definition at line 98 of file fairQueue.h.

    {
        ellInit(&list);
    }

template<typename T>

epics::pvAccess::fair_queue< T >::~fair_queue ( )

inline

Definition at line 102 of file fairQueue.h.

    {
        clear();
        assert(ellCount(&list)==0);
    }

Member Function Documentation

template<typename T>

void epics::pvAccess::fair_queue< T >::clear ( )

inline

Remove all items.

Postcondition

empty()==true

Definition at line 110 of file fairQueue.h.

    {
        // destroy after unlock
        std::vector<value_type> garbage;
        {
            guard_t G(mutex);

            garbage.resize(unsigned(ellCount(&list)));
            size_t i=0;

            while(ELLNODE *cur = ellGet(&list)) {
                typedef typename entry::enode_t enode_t;
                enode_t *PN = CONTAINER(cur, enode_t, node);
                entry *P = PN->self;
                assert(P->owner==this);
                assert(P->Qcnt>0);

                PN->node.previous = PN->node.next = NULL;
                P->owner = NULL;
                P->Qcnt = 0u;
                garbage[i++].swap(P->holder);
            }
        }
    }

template<typename T>

bool epics::pvAccess::fair_queue< T >::empty ( ) const

inline

Definition at line 135 of file fairQueue.h.

                       {
        guard_t G(mutex);
        return ellFirst(&list)==NULL;
    }

template<typename T>

void epics::pvAccess::fair_queue< T >::pop_front ( value_type &  ret )

inline

Definition at line 188 of file fairQueue.h.

    {
        while(1) {
            pop_front_try(ret);
            if(ret)
                break;
            wakeup.wait();
        }
    }

template<typename T>

bool epics::pvAccess::fair_queue< T >::pop_front ( value_type &  ret, double  timeout  )

inline

Definition at line 198 of file fairQueue.h.

    {
        while(1) {
            pop_front_try(ret);
            if(ret)
                return true;
            if(!wakeup.wait(timeout))
                return false;
        }
    }

template<typename T>

bool epics::pvAccess::fair_queue< T >::pop_front_try ( value_type &  ret )

inline

Definition at line 160 of file fairQueue.h.

    {
        ret.reset();
        guard_t G(mutex);
        ELLNODE *cur = ellGet(&list); // pop_front

        if(cur) {
            typedef typename entry::enode_t enode_t;
            enode_t *PN = CONTAINER(cur, enode_t, node);
            entry *P = PN->self;
            assert(P->owner==this);
            assert(P->Qcnt>0);
            if(--P->Qcnt==0) {
                PN->node.previous = PN->node.next = NULL;
                P->owner = NULL;

                ret.swap(P->holder);
            } else {
                ellAdd(&list, &P->enode.node); // push_back

                ret = P->holder;
            }
            return true;
        } else {
            return false;
        }
    }

template<typename T>

void epics::pvAccess::fair_queue< T >::push_back ( const value_type &  ent )

inline

Definition at line 140 of file fairQueue.h.

    {
        bool wake;
        entry *P = ent.get();
        {
            guard_t G(mutex);
            wake = ellFirst(&list)==NULL; // empty queue

            if(P->Qcnt++==0) {
                // not in list
                assert(P->owner==NULL);
                P->owner = this;
                P->holder = ent; // the list will hold a reference
                ellAdd(&list, &P->enode.node); // push_back
            } else
                assert(P->owner==this);
        }
        if(wake) wakeup.signal();
    }

---

The documentation for this class was generated from the following file:

• modules/pvAccess/src/utils/pv/fairQueue.h