Active.h

#pragma once

#include "SyncQueues.h"
#include "helpers.h"

template<class RT>
class Active {

public:
    typedef std::function<RT(StopCondition* const sc)> Command;

protected:
    StopCondition stop;

    bool done;

    SynchronizedQueue<const std::function<void(StopCondition* const sc)>> ptq;

    std::thread thread;

protected:
    Active(const Active&);

    void operator=(const Active&);

protected:

public:
    Active()
        : stop()
        , done(false)
        , ptq()
        , thread([=]() {while ( !done ) {
            stop.Set(false);
            ptq.Dequeue()(&stop); }
            DBOUT(L"Active::thread ended"); }) {
    }

    ~Active() {
        Quit();
    }

    std::future<RT> Send(const Command& _cmd) {
        // make a shared_ptr to the promise (we need this since promise it non-copyable
        auto p = std::make_shared<std::promise<RT>>();

        // get the future of the promise to return it at the end
        std::future<RT> ret = std::future<RT>(std::move(p->get_future()));

        // the promise pointer is caught by the lambda, thus outlives the Send function
        ptq.Enqueue([=](StopCondition* const sc) {
            p->set_value(_cmd(sc));
        });

        return ret;
    }

    void AbortCurrent() {
        stop.Set(true);
    }

    void Quit() {
        ptq.Enqueue( [=] (StopCondition* const sc)  { done = true; DBOUT(L"Active::Quit enqueued\n");} );
        if ( thread.joinable() )    // This is not unfallably safe, could get unjoinable right after if?!
            thread.join();
        DBOUT(L"Active::Quitted\n");
    }
};