LockedQueue.h

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/
 
#ifndef LOCKEDQUEUE_H
#define LOCKEDQUEUE_H
 
#include "Debugging/Errors.h"
#include "Platform/Threading.h"
#include <assert.h>
#include <cstddef>
#include <deque>
#include <mutex>
 
namespace Skyfire
{
    template <class T, class LockType, typename StorageType = std::deque<T> >
    class LockedQueue
    {
        LockType _lock;

        StorageType _queue;

        volatile bool _canceled;
 
    public:
        LockedQueue() : _canceled(false) { }

        virtual ~LockedQueue() { }

        std::size_t add(const T& item)
        {
            std::lock_guard<LockType> g(this->_lock);
 
            //ASSERT(!this->_canceled);
            // throw Cancellation_Exception();
 
            _queue.push_back(item);
 
            return _queue.size();
        }

        bool next(T& result)
        {
            std::lock_guard<LockType> g(this->_lock);
 
            if (_queue.empty())
                return false;
 
            //ASSERT (!_queue.empty() || !this->_canceled);
            // throw Cancellation_Exception();
            result = _queue.front();
            _queue.pop_front();
 
            return true;
        }
 
        template<class Checker>
        bool next(T& result, Checker& check)
        {
            std::lock_guard<LockType> g(this->_lock);
 
            if (_queue.empty())
                return false;
 
            result = _queue.front();
            if (!check.Process(result))
                return false;
 
            _queue.pop_front();
            return true;
        }

        T& peek(bool autoUnlock = false)
        {
            lock();
 
            T& result = _queue.front();
 
            if (autoUnlock)
                unlock();
 
            return result;
        }

        void cancel()
        {
            lock();
 
            _canceled = true;
 
            unlock();
        }

        bool cancelled()
        {
            std::lock_guard<LockType> g(this->_lock);
            return _canceled;
        }

        void lock()
        {
            this->_lock.lock();
        }

        void unlock()
        {
            this->_lock.unlock();
        }

        void pop_front()
        {
            std::lock_guard<LockType> g(this->_lock);
            _queue.pop_front();
        }

        bool empty()
        {
            std::lock_guard<LockType> g(this->_lock);
            return _queue.empty();
        }

        std::size_t size()
        {
            std::lock_guard<LockType> g(this->_lock);
            return _queue.size();
        }
    };
}
 
#endif