PackagedTask.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Thread/Future/Future.h"

namespace honey
{

template<class Sig> class PackagedTask;

template<class R, class... Param>
class PackagedTask<R (Param...)> : mt::NoCopy
{
    template<class, class> friend class FutureCommon;
    
public:
    PackagedTask()                                  : _func(nullptr), _invoked(false) {}
    template<class F>
    PackagedTask(F&& f)                             : _func(forward<F>(f)), _invoked(false) {}
    template<class F, class Alloc>
    PackagedTask(F&& f, Alloc&& a)                  : _func(std::allocator_arg_t(), a, forward<F>(f)), _promise(a), _invoked(false) {}
    PackagedTask(PackagedTask&& rhs) noexcept       : _func(move(rhs._func)), _promise(move(rhs._promise)), _invoked(rhs._invoked) {}

    PackagedTask& operator=(PackagedTask&& rhs)     { _func = move(rhs._func); _promise = move(rhs._promise); _invoked = rhs._invoked; return *this; }


    Future<R> future()                              { return _promise.future(); }


    template<class... Args>
    void operator()(Args&&... args)                 { invoke(true, forward<Args>(args)...); }
    template<class... Args>
    void invoke_delayedReady(Args&&... args)        { invoke(false, forward<Args>(args)...); }

    void setReady(bool reset = false)
    {
        if (!valid()) throw_ future::NoState();
        assert(_invoked);
        if (reset)
        {
            Promise<R> promise(move(_promise));
            this->reset();
            promise._state->setReady();
        }
        else
            _promise._state->setReady();
    }

    bool valid() const                              { return _promise.valid(); }
    void reset()                                    { *this = PackagedTask(move(_func)); }
    
    function<R (Param...)>& getFunc()               { return _func; }
    template<class F>
    void setFunc(F&& f)                             { _func = forward<F>(f); }
    
private:
    template<class F, class Alloc>
    PackagedTask(F&& f, Alloc&& a, Promise<R>&& promise) :
        _func(std::allocator_arg_t(), forward<Alloc>(a), forward<F>(f)), _promise(move(promise)), _invoked(false) {}
    
    template<class... Args>
    void invoke(bool setReady, Args&&... args)
    {
        if (!valid()) throw_ future::NoState();
        if (_invoked) throw_ future::AlreadySatisfied();
        _invoked = true;
        future::priv::invoke<R>()(*_promise._state, setReady, _func, forward<Args>(args)...);
    }

    function<R (Param...)> _func;
    Promise<R> _promise;
    bool _invoked;
};

}