process.hpp

#ifndef ENTT_PROCESS_PROCESS_HPP
#define ENTT_PROCESS_PROCESS_HPP


#include <type_traits>
#include <functional>
#include <utility>
#include "../config/config.h"


namespace entt {


template<typename Derived, typename Delta>
class Process {
    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 Target = Derived>
    auto tick(int, tag<State::UNINITIALIZED>, void *data)
    -> decltype(std::declval<Target>().init(data)) {
        static_cast<Target *>(this)->init(data);
    }

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

    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 &&...) const ENTT_NOEXCEPT {}

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

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

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

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

public:
    using delta_type = Delta;

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

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

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

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

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

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

    bool rejected() const ENTT_NOEXCEPT {
        return stopped;
    }

    void tick(const Delta delta, void *data = nullptr) {
        switch (current) {
        case State::UNINITIALIZED:
            tick(0, tag<State::UNINITIALIZED>{}, data);
            current = State::RUNNING;
            // no break on purpose, tasks are executed immediately
        case State::RUNNING:
            tick(0, tag<State::RUNNING>{}, delta, data);
        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(const Delta delta, void *data) {
        Func::operator()(delta, data, [this]() { this->succeed(); }, [this]() { this->fail(); });
    }
};


}


#endif // ENTT_PROCESS_PROCESS_HPP