TSQueue.hpp

Go to the documentation of this file.

//
// Created by cbihan on 28/09/2021.
//
 
#pragma once
 
#include <mutex>
#include <condition_variable>
#include <deque>
#include <chrono>
 
namespace Babel
{
    template<typename T>
    class TSQueue
    {
    public:
        TSQueue() = default;
 
        TSQueue(const TSQueue<T> &) = delete;
 
        ~TSQueue()
        {
            this->clear();
        };
 
        const T &front()
        {
            std::scoped_lock lock(this->_mutex);
            return this->_queue.front();
        }
 
        const T &back()
        {
            std::scoped_lock lock(this->_mutex);
            return this->_queue.back();
        }
 
        T popFront()
        {
            std::scoped_lock lock(this->_mutex);
            auto t = std::move(this->_queue.front());
            this->_queue.pop_front();
            return t;
        }
 
        T popBack()
        {
            std::scoped_lock lock(this->_mutex);
            auto t = std::move(this->_queue.back());
            this->_queue.pop_back();
            return t;
        }
 
        void pushFront(const T &t)
        {
            std::scoped_lock lock(this->_mutex);
            this->_queue.push_front(t);
            this->_blocker.notify_one();
        }
 
        void pushBack(const T &t)
        {
            std::scoped_lock lock(this->_mutex);
            this->_queue.push_back(t);
            this->_blocker.notify_one();
        }
 
        bool empty()
        {
            std::scoped_lock lock(this->_mutex);
            return this->_queue.empty();
        }
 
        size_t count()
        {
            std::scoped_lock lock(this->_mutex);
            return this->_queue.size();
        }
 
        void clear()
        {
            std::scoped_lock lock(this->_mutex);
            this->_queue.clear();
        }
 
        template<typename TimeType>
        void waitFor(std::chrono::duration<TimeType> time)
        {
            using namespace std::chrono_literals;
            std::unique_lock<std::mutex> ul(this->_waitMutex);
            this->_blocker.wait_for(ul, time);
        }
 
    protected:
        std::mutex _mutex;
        std::deque<T> _queue;
        std::condition_variable _blocker;
        std::mutex _waitMutex;
    };
}