process.hpp

#ifndef ENTT_PROCESS_PROCESS_HPP
#define ENTT_PROCESS_PROCESS_HPP


#include <type_traits>
#include <functional>
#include <utility>


namespace entt {


namespace {


struct BaseProcess {
    enum class State: unsigned int {
        UNINITIALIZED = 0,
        RUNNING,
        PAUSED,
        SUCCEEDED,
        FAILED,
        ABORTED,
        FINISHED
    };

    template<State state>
    using tag = std::integral_constant<State, state>;
};


}


template<typename Derived, typename Delta>
class Process: private BaseProcess {
    template<typename Target = Derived>
    auto tick(int, tag<State::UNINITIALIZED>)
    -> decltype(std::declval<Target>().init()) {
        static_cast<Target *>(this)->init();
    }

    template<typename Target = Derived>
    auto tick(int, tag<State::RUNNING>, Delta delta)
    -> decltype(std::declval<Target>().update(delta)) {
        static_cast<Target *>(this)->update(delta);
    }

    template<typename Target = Derived>
    auto tick(int, tag<State::SUCCEEDED>)
    -> decltype(std::declval<Target>().succeeded()) {
        static_cast<Target *>(this)->succeeded();
    }

    template<typename Target = Derived>
    auto tick(int, tag<State::FAILED>)
    -> decltype(std::declval<Target>().failed()) {
        static_cast<Target *>(this)->failed();
    }

    template<typename Target = Derived>
    auto tick(int, tag<State::ABORTED>)
    -> decltype(std::declval<Target>().aborted()) {
        static_cast<Target *>(this)->aborted();
    }

    template<State S, typename... Args>
    void tick(char, tag<S>, Args&&...) {}

protected:
    void succeed() noexcept {
        if(alive()) {
            current = State::SUCCEEDED;
        }
    }

    void fail() noexcept {
        if(alive()) {
            current = State::FAILED;
        }
    }

    void pause() noexcept {
        if(current == State::RUNNING) {
            current = State::PAUSED;
        }
    }

    void unpause() noexcept {
        if(current  == State::PAUSED) {
            current  = State::RUNNING;
        }
    }

public:
    using delta_type = Delta;

    ~Process() noexcept {
        static_assert(std::is_base_of<Process, Derived>::value, "!");
    }

    void abort(bool immediately = false) noexcept {
        if(alive()) {
            current = State::ABORTED;

            if(immediately) {
                tick(0);
            }
        }
    }

    bool alive() const noexcept {
        return current == State::RUNNING || current == State::PAUSED;
    }

    bool dead() const noexcept {
        return current == State::FINISHED;
    }

    bool paused() const noexcept {
        return current == State::PAUSED;
    }

    bool rejected() const noexcept {
        return stopped;
    }

    void tick(Delta delta) {
        switch (current) {
        case State::UNINITIALIZED:
            tick(0, tag<State::UNINITIALIZED>{});
            current = State::RUNNING;
            // no break on purpose, tasks are executed immediately
        case State::RUNNING:
            tick(0, tag<State::RUNNING>{}, delta);
        default:
            // suppress warnings
            break;
        }

        // if it's dead, it must be notified and removed immediately
        switch(current) {
        case State::SUCCEEDED:
            tick(0, tag<State::SUCCEEDED>{});
            current = State::FINISHED;
            break;
        case State::FAILED:
            tick(0, tag<State::FAILED>{});
            current = State::FINISHED;
            stopped = true;
            break;
        case State::ABORTED:
            tick(0, tag<State::ABORTED>{});
            current = State::FINISHED;
            stopped = true;
            break;
        default:
            // suppress warnings
            break;
        }
    }

private:
    State current{State::UNINITIALIZED};
    bool stopped{false};
};


template<typename Func, typename Delta>
struct ProcessAdaptor: Process<ProcessAdaptor<Func, Delta>, Delta>, private Func {
    template<typename... Args>
    ProcessAdaptor(Args&&... args)
        : Func{std::forward<Args>(args)...}
    {}

    void update(Delta delta) {
        Func::operator()(delta, [this](){ this->succeed(); }, [this](){ this->fail(); });
    }
};


}


#endif // ENTT_PROCESS_PROCESS_HPP