Queue.h

Go to the documentation of this file.

#ifndef MARLINMT_CONCURRENCY_QUEUE_h
#define MARLINMT_CONCURRENCY_QUEUE_h 1

// -- std headers
#include <mutex>
#include <utility>
#include <queue>

namespace marlinmt {

  namespace concurrency {

    template <
      typename T,
      class = typename std::enable_if<std::is_move_assignable<T>::value>::type>
    class Queue {
    public:
      Queue() = default ;
      ~Queue() = default ;
      Queue(const Queue&) = delete ;
      Queue& operator=(const Queue&) = delete ;

      Queue( std::size_t maxsize ) {
        _maxSize = maxsize ;
      }

      bool push(T &value) {
        std::unique_lock<std::mutex> lock(_mutex) ;
        if( _queue.size() >= _maxSize ) {
          return false ;
        }
        _queue.push( std::move(value) ) ;
        return true ;
      }

      bool pop( T & value ) {
        std::unique_lock<std::mutex> lock(_mutex) ;
        if( _queue.empty() ) {
          return false ;
        }
        value = std::move(_queue.front()) ;
        _queue.pop() ;
        return true ;
      }

      bool empty() const {
        std::unique_lock<std::mutex> lock(_mutex) ;
        return _queue.empty() ;
      }

      std::size_t maxSize() const {
        std::unique_lock<std::mutex> lock(_mutex) ;
        return _maxSize ;
      }

      std::size_t setMaxSize( std::size_t maxsize ) {
        std::unique_lock<std::mutex> lock(_mutex) ;
        std::swap( _maxSize, maxsize ) ;
        return maxsize ;
      }

      bool isFull() const {
        std::unique_lock<std::mutex> lock(_mutex) ;
        return (_queue.size() >= _maxSize) ;
      }

      void clear() {
        std::unique_lock<std::mutex> lock(_mutex) ;
        while( not _queue.empty() ) {
          _queue.pop() ;
        }
      }

      std::size_t freeSlots() const {
        std::unique_lock<std::mutex> lock(_mutex) ;
        return (_queue.size() >= _maxSize ? 0 : (_maxSize - _queue.size())) ;
      }

    private:
      std::queue<T>              _queue {} ;
      mutable std::mutex         _mutex {} ;
      std::size_t                _maxSize {std::numeric_limits<std::size_t>::max()} ;
    };

  } // end namespace concurrency

} // end namespace marlinmt

#endif