LockedQueue.hpp

#ifndef ORO_LOCKED_QUEUE_HPP
#define ORO_LOCKED_QUEUE_HPP

#include <deque>
#include "BufferPolicy.hpp"
#include "os/Mutex.hpp"
#include "os/MutexLock.hpp"

namespace RTT
{
    template< class T, class ReadPolicy = NonBlockingPolicy, class WritePolicy = NonBlockingPolicy>
    class LockedQueue
    {
    public:
        typedef T value_t;
    private:
        typedef std::deque<value_t> BufferType;
        typedef typename BufferType::iterator Iterator;
        typedef typename BufferType::const_iterator CIterator;
        mutable OS::Mutex lock;
        BufferType data;

        int cap;
        WritePolicy write_policy;
        ReadPolicy read_policy;

        int counter;
        int dcounter;
    public:
        typedef unsigned int size_type;

        LockedQueue(unsigned int lsize, unsigned int unused = 0)
            : cap(lsize),
              write_policy(lsize), read_policy(0),
              counter(0), dcounter(0)
        {
            data.resize(lsize);
            data.resize(0);
        }

        ~LockedQueue() {
        }

        size_type capacity() const
        {
            return cap;
        }

        size_type size() const
        {
            OS::MutexLock locker(lock);
            return data.size();
        }

        bool isEmpty() const
        {
            OS::MutexLock locker(lock);
            return data.empty();
        }

        bool isFull() const
        {
            OS::MutexLock locker(lock);
            return data.size() ==  cap;
        }

        void clear()
        {
            OS::MutexLock locker(lock);
            data.clear();
        }

        bool enqueue(const T& value)
        {
            write_policy.pop();
            {
                OS::MutexLock locker(lock);
                if (cap == data.size() )
                    return false;
                data.push_back(value);
            }
            read_policy.push();
            return true;
        }

        int enqueueCounted(const T& value)
        {
            int ret;
            write_policy.pop();
            {
                OS::MutexLock locker(lock);
                if (cap == data.size() )
                    return 0;
                data.push_back(value);
                ret = ++counter;
            }
            read_policy.push();
            return ret;
        }

        bool dequeue( T& result )
        {
            read_policy.pop();
            {
                OS::MutexLock locker(lock);
                if ( data.empty() )
                    return false;
                result = data.front();
                data.pop_front();
            }
            write_policy.push();
            return true;
        }

        int dequeueCounted( T& result )
        {
            int ret;
            read_policy.pop();
            {
                OS::MutexLock locker(lock);
                if ( data.empty() )
                    return 0;
                result = data.front();
                data.pop_front();
                ret = ++dcounter;
            }
            write_policy.push();
            return ret;
        }

        value_t front() const
        {
            OS::MutexLock locker(lock);
            value_t item = value_t();
            if ( !data.empty() )
                item = data.front();
            return item;
        }

        value_t back() const
        {
            OS::MutexLock locker(lock);
            value_t item = value_t();
            if ( !data.empty() )
                item = data.back();
            return item;
        }

    };

}

#endif