QueueElement.h

Go to the documentation of this file.

#ifndef MARLINMT_CONCURRENCY_QUEUEELEMENT_h
#define MARLINMT_CONCURRENCY_QUEUEELEMENT_h 1

// -- std headers
#include <memory>
#include <future>

namespace marlinmt {

  namespace concurrency {

    template <typename IN, typename OUT>
    class QueueElement {
    public:
      // no copy
      QueueElement() = default ;
      QueueElement( const QueueElement<IN,OUT> & ) = delete ;
      QueueElement &operator=( const QueueElement<IN,OUT> & ) = delete ;

      QueueElement( IN && input ) :
        _input(input) {
        /* nop */
      }

      QueueElement( QueueElement<IN,OUT> &&rhs ) {
        *this = std::move(rhs) ;
      }

      QueueElement &operator=( QueueElement<IN,OUT> &&rhs ) {
        _promise = std::move(rhs._promise) ;
        _input = std::move(rhs._input) ;
        return *this ;
      }
      
      std::shared_ptr<std::promise<OUT>> promise() const {
        return _promise ;
      }

      void setValue( OUT && output ) {
        _promise->set_value( output ) ;
      }

      IN takeInput() {
        return std::move(_input) ;
      }

    private:
      std::shared_ptr<std::promise<OUT>>    _promise {std::make_shared<std::promise<OUT>>()} ;
      IN                                    _input {} ;
    };

    template <typename OUT>
    class QueueElement<void, OUT> {
    public:
      // no copy
      QueueElement( const QueueElement<void,OUT> & ) = delete ;
      QueueElement &operator=( const QueueElement<void,OUT> & ) = delete ;
      QueueElement() = default ;
      QueueElement( QueueElement<void,OUT> &&rhs ) { *this = std::move(rhs) ; }
      QueueElement &operator=( QueueElement<void,OUT> &&rhs ) { _promise = std::move(rhs._promise) ; return *this ; }
      std::shared_ptr<std::promise<OUT>> promise() const { return _promise ; }
      void setValue( OUT && output ) { _promise->set_value( output ) ; }
    private:
      std::shared_ptr<std::promise<OUT>>    _promise {std::make_shared<std::promise<OUT>>()} ;
    };

    template <typename IN>
    class QueueElement<IN, void> {
    public:
      // no copy
      QueueElement() = default ;
      QueueElement( const QueueElement<IN,void> & ) = delete ;
      QueueElement &operator=( const QueueElement<IN,void> & ) = delete ;
      QueueElement( IN && input ) : _input(input) {}
      QueueElement( QueueElement<IN,void> &&rhs ) { *this = std::move(rhs) ; }
      QueueElement &operator=( QueueElement<IN,void> &&rhs ) {
        _promise = std::move(rhs._promise) ;
        _input = std::move(rhs._input) ;
        return *this ;
      }
      std::shared_ptr<std::promise<void>> promise() const { return _promise ; }
      void setValue() { _promise->set_value() ; }
      IN takeInput() { return std::move(_input) ; }
    private:
      std::shared_ptr<std::promise<void>>    _promise {std::make_shared<std::promise<void>>()} ;
      IN                                     _input {} ;
    };

    template <>
    class QueueElement<void, void> {
    public:
      // no copy
      QueueElement( const QueueElement<void,void> & ) = delete ;
      QueueElement &operator=( const QueueElement<void,void> & ) = delete ;
      QueueElement() = default ;
      QueueElement( QueueElement<void,void> &&rhs ) { *this = std::move(rhs) ; }
      QueueElement &operator=( QueueElement<void,void> &&rhs ) { _promise = std::move(rhs._promise) ; return *this ; }
      std::shared_ptr<std::promise<void>> promise() const { return _promise ; }
      void setValue() { _promise->set_value() ; }
    private:
      std::shared_ptr<std::promise<void>>    _promise {std::make_shared<std::promise<void>>()} ;
    };

  } // end namespace concurrency

} // end namespace marlinmt

#endif