BaseController_p.h

#pragma once

#include "parameters/Scope.h"
#include "ScopeDatatypes.h"
#include "helpers/ScopeException.h"

namespace scope {

template<uint32_t N_ACTIVES, bool STATIC_PIMPL>
class BaseController<N_ACTIVES, STATIC_PIMPL>::Impl {

protected:
    std::array<std::shared_future<ControllerReturnStatus>, N_ACTIVES> futures;

    std::array<StopCondition, N_ACTIVES> stops;

    parameters::Scope parameters;

private:
    Impl(const Impl& i);

    Impl operator=(const Impl& i);

protected:
    virtual ControllerReturnStatus Run(StopCondition* const ac, const uint32_t& _n) {
        DBOUT(L"BaseControllerImpl::Run - this should not happen, the derived class' Run method should have been called\n");
        while ( !ac->IsSet() )
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        ac->Set(false);
        return ControllerReturnStatus(ControllerReturnStatus::error);           // If this ever gets executed, something went wrong...
    }

public:
    Impl(const parameters::Scope& _parameters)
        : parameters(_parameters) {
    }

    virtual ~Impl() {
        DBOUT(L"BaseController::Impl::~Impl\n");
    }

    virtual void Start(const parameters::Scope& _params) {
        DBOUT(L"BaseController::Impl::Start\n");
        parameters = _params;
        for( uint32_t a = 0; a < N_ACTIVES ; a++ ) {
            stops[a].Set(false);
            // Let "Run" run asynchronously and get its future
            futures[a] = std::async(std::bind(&Impl::Run, this, &stops[a], a));
        }
    }

    virtual void StopOne(const uint32_t& _a) {
        ATLASSERT(_a < N_ACTIVES);
        stops[_a].Set(true);
    }

    virtual void StopAll() {
        DBOUT(L"BaseController::Impl::Stop\n");
        for ( uint32_t a = 0 ; a < N_ACTIVES ; a++ )
            StopOne(a);
    }

    virtual ControllerReturnStatus WaitForOne(const uint32_t& _a, const int32_t& _wait_time) {
        if ( futures[_a].valid() ) {
            std::future_status::future_status state(std::future_status::ready);

            // Wait (either indefinitely or _wait_time
            if ( _wait_time == -1 )
                futures[_a].wait();
            else
                state = futures[_a].wait_for(std::chrono::milliseconds(_wait_time));

            // If async returned, get the future's value here
            if ( state == std::future_status::ready )
                return futures[_a].get();
            // Landing here means, wait_for ran into a timeout
            else
                throw ScopeException("WaitForOne did not succeed, async thread did not return");
        }
        else
            DBOUT(L"WaitForOne future is not valid (async worker function is not running)");

        return ControllerReturnStatus::error;
    }

    virtual ControllerReturnStatus WaitForAll(const int32_t& _wait_time) {
        ControllerReturnStatus totalresult(ControllerReturnStatus::none);
        for ( uint32_t a = 0 ; a < N_ACTIVES ; a++ ) {
            try {
                totalresult = (ControllerReturnStatus)( totalresult | WaitForOne(a, _wait_time) );
            }
            catch (... ) { ScopeExceptionHandler(__FUNCTION__, true, true); }
        }
        DBOUT(L"BaseController::Impl::WaitForAll returns\n");
        return totalresult;
    }
};

}