process.hpp

#ifndef ENTT_PROCESS_PROCESS_HPP
#define ENTT_PROCESS_PROCESS_HPP
 
#include <cstdint>
#include <type_traits>
#include <utility>
#include "fwd.hpp"
 
namespace entt {

template<typename Derived, typename Delta>
class process {
    enum class state : std::uint8_t {
        uninitialized = 0,
        running,
        paused,
        succeeded,
        failed,
        aborted,
        finished,
        rejected
    };
 
    template<typename Target = Derived>
    auto next(std::integral_constant<state, state::uninitialized>)
        -> decltype(std::declval<Target>().init(), void()) {
        static_cast<Target *>(this)->init();
    }
 
    template<typename Target = Derived>
    auto next(std::integral_constant<state, state::running>, Delta delta, void *data)
        -> decltype(std::declval<Target>().update(delta, data), void()) {
        static_cast<Target *>(this)->update(delta, data);
    }
 
    template<typename Target = Derived>
    auto next(std::integral_constant<state, state::succeeded>)
        -> decltype(std::declval<Target>().succeeded(), void()) {
        static_cast<Target *>(this)->succeeded();
    }
 
    template<typename Target = Derived>
    auto next(std::integral_constant<state, state::failed>)
        -> decltype(std::declval<Target>().failed(), void()) {
        static_cast<Target *>(this)->failed();
    }
 
    template<typename Target = Derived>
    auto next(std::integral_constant<state, state::aborted>)
        -> decltype(std::declval<Target>().aborted(), void()) {
        static_cast<Target *>(this)->aborted();
    }
 
    template<typename... Args>
    void next(Args...) const noexcept {}
 
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;

    constexpr process() = default;

    process(const process &) = default;

    process(process &&) noexcept = default;

    process &operator=(const process &) = default;

    process &operator=(process &&) noexcept = default;

    virtual ~process() {
        static_assert(std::is_base_of_v<process, Derived>, "Incorrect use of the class template");
    }

    void abort(const bool immediate = false) {
        if(alive()) {
            current = state::aborted;
 
            if(immediate) {
                tick({});
            }
        }
    }

    [[nodiscard]] bool alive() const noexcept {
        return current == state::running || current == state::paused;
    }

    [[nodiscard]] bool finished() const noexcept {
        return current == state::finished;
    }

    [[nodiscard]] bool paused() const noexcept {
        return current == state::paused;
    }

    [[nodiscard]] bool rejected() const noexcept {
        return current == state::rejected;
    }

    void tick(const Delta delta, void *data = nullptr) {
        switch(current) {
        case state::uninitialized:
            next(std::integral_constant<state, state::uninitialized>{});
            current = state::running;
            break;
        case state::running:
            next(std::integral_constant<state, state::running>{}, delta, data);
            break;
        default:
            // suppress warnings
            break;
        }
 
        // if it's dead, it must be notified and removed immediately
        switch(current) {
        case state::succeeded:
            next(std::integral_constant<state, state::succeeded>{});
            current = state::finished;
            break;
        case state::failed:
            next(std::integral_constant<state, state::failed>{});
            current = state::rejected;
            break;
        case state::aborted:
            next(std::integral_constant<state, state::aborted>{});
            current = state::rejected;
            break;
        default:
            // suppress warnings
            break;
        }
    }
 
private:
    state current{state::uninitialized};
};

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

    void update(const Delta delta, void *data) {
        Func::operator()(
            delta,
            data,
            [this]() { this->succeed(); },
            [this]() { this->fail(); });
    }
};
 
} // namespace entt
 
#endif