EventQueue.h

Go to the documentation of this file.

#ifndef EVENTQUEUE_H_
#define EVENTQUEUE_H_

#include "SttclTime.h"
#include "SttclSemaphore.h"
#include "SttclMutex.h"
#if !defined(STTCL_USE_STL)
#else
#include <deque>
#endif

#if defined(STTCL_USE_STL)
#if !defined(STTCL_DEFAULT_DEQUEIMPL)
#define STTCL_DEFAULT_DEQUEIMPL(__T__) std::deque<__T__>
#endif
#endif

#if !defined(STTCL_DEFAULT_DEQUEIMPL)
#error "You need to define a default double ended queue implementation for sttcl"
#endif

#define EAIGNORE_BEGIN
#define EAIGNORE_END

namespace sttcl
{

template
< class T
, class TimeDurationType = TimeDuration<STTCL_DEFAULT_TIMEDURATIONIMPL>
, class SemaphoreType = sttcl::internal::SttclSemaphore<STTCL_DEFAULT_SEMAPHOREIMPL,TimeDurationType>
, class MutexType = sttcl::internal::SttclMutex<STTCL_DEFAULT_MUTEXIMPL,TimeDurationType>
EAIGNORE_BEGIN
, class InnerQueueType = STTCL_DEFAULT_DEQUEIMPL(T)
EAIGNORE_END
>
class EventQueue
{
public:
        EventQueue()
        : eventQueue()
        {
        }
        ~EventQueue()
        {
        }

        void push_back(const T& event)
        {
                { sttcl::internal::AutoLocker<MutexType> lock(eventQueueMutex);
                        eventQueue.push_back(event);
                }
                eventsAvailable.post();
        }

        T& front()
        {
                sttcl::internal::AutoLocker<MutexType> lock(eventQueueMutex);
                return eventQueue.front();
        }

        void pop_front()
        {
                sttcl::internal::AutoLocker<MutexType> lock(eventQueueMutex);
                eventQueue.pop_front();
        }

        bool waitForEvents()
        {
                eventsAvailable.wait();
                return !empty();
        }

        bool waitForEvents(TimeDurationType timeout)
        {
                return eventsAvailable.try_wait(timeout) && !empty();
        }

        bool empty()
        {
                sttcl::internal::AutoLocker<MutexType> lock(eventQueueMutex);
                return eventQueue.empty();
        }

        void unblock()
        {
                eventsAvailable.post();
        }
private:
        EventQueue(const EventQueue<T,TimeDurationType,SemaphoreType,MutexType,InnerQueueType>& rhs); 
        EventQueue<T,TimeDurationType,SemaphoreType,MutexType,InnerQueueType>& operator=(const EventQueue<T,TimeDurationType,SemaphoreType,MutexType,InnerQueueType>& rhs); 

        InnerQueueType eventQueue;
        MutexType eventQueueMutex;
        SemaphoreType eventsAvailable;
};


}



#endif /* EVENTQUEUE_H_ */