DefinitionRuntime.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Generation.h"
#include "common/ResourceRef.h"
#include "common/Result.h"
 
#include <cstdint>
#include <exception>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
 
namespace eve::definition {
 
enum class ReloadPolicy : std::uint8_t {
    KeepInstanceValues,
    ReapplyDefaults,
    RebuildInstance,
    RejectWhileActive,
};
 
inline const char* reloadPolicyName(ReloadPolicy policy) noexcept {
    switch (policy) {
        case ReloadPolicy::KeepInstanceValues: return "keep_instance_values";
        case ReloadPolicy::ReapplyDefaults: return "reapply_defaults";
        case ReloadPolicy::RebuildInstance: return "rebuild_instance";
        case ReloadPolicy::RejectWhileActive: return "reject_while_active";
    }
    return "unknown";
}
 
struct DefinitionHandle {
    eve::DefinitionRef reference;
    eve::Generation    generation;
 
    [[nodiscard]] bool isValid() const noexcept { return reference.id().isValid() && !generation.isZero(); }
 
    friend bool operator==(const DefinitionHandle&, const DefinitionHandle&) noexcept = default;
};
 
struct InstanceIdentity {
    eve::PersistentId  instanceId;
    eve::DefinitionRef definition;
    eve::Generation    definitionGeneration;
 
    [[nodiscard]] static eve::Result<InstanceIdentity> create(eve::PersistentId  instanceId,
                                                              eve::DefinitionRef definition,
                                                              eve::Generation    definitionGeneration) {
        if (instanceId.isNil())
            return eve::Result<InstanceIdentity>::failure(eve::Diagnostic::error(
                eve::DiagnosticCode::InvalidArgument, "runtime instance identity must not be nil", "instanceId", {},
                "common.definitions"));
        if (!definition.id().isValid())
            return eve::Result<InstanceIdentity>::failure(
                eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument, "runtime definition reference is invalid",
                                       "definition", {}, "common.definitions"));
        if (definitionGeneration.isZero())
            return eve::Result<InstanceIdentity>::failure(eve::Diagnostic::error(
                eve::DiagnosticCode::InvalidArgument, "runtime definition generation must be positive",
                "definitionGeneration", {}, "common.definitions"));
        return eve::Result<InstanceIdentity>::success(
            InstanceIdentity{instanceId, std::move(definition), definitionGeneration});
    }
 
    [[nodiscard]] DefinitionHandle definitionHandle() const noexcept {
        return DefinitionHandle{definition, definitionGeneration};
    }
 
    [[nodiscard]] bool isValid() const noexcept {
        return !instanceId.isNil() && definition.id().isValid() && !definitionGeneration.isZero();
    }
 
    friend bool operator==(const InstanceIdentity&, const InstanceIdentity&) noexcept = default;
};
 
enum class ReloadDisposition : std::uint8_t {
    Unchanged,
    Kept,
    DefaultsReapplied,
    Rebuilt,
};
 
struct ReloadOutcome {
    eve::PersistentId  instanceId;
    eve::DefinitionRef definition;
    eve::Generation    oldGeneration;
    eve::Generation    newGeneration;
    ReloadPolicy       policy      = ReloadPolicy::KeepInstanceValues;
    ReloadDisposition  disposition = ReloadDisposition::Unchanged;
 
    [[nodiscard]] bool changed() const noexcept { return oldGeneration != newGeneration; }
};
 
class EVENGINE_API RuntimeInstanceCore {
public:
    using CloneFunction = void* (*)(const void*);
    using AssignFunction = void (*)(void* destination, const void* source);
    using DestroyFunction = void (*)(void*) noexcept;
    using RebuildFunction =
        std::function<eve::Result<void*>(const void*, const InstanceIdentity&, const DefinitionHandle&)>;
 
    RuntimeInstanceCore(InstanceIdentity identity, void* state, CloneFunction clone, AssignFunction assign,
                        DestroyFunction destroy, bool active) noexcept;
    ~RuntimeInstanceCore();
 
    RuntimeInstanceCore(const RuntimeInstanceCore& other);
    RuntimeInstanceCore& operator=(const RuntimeInstanceCore& other);
    RuntimeInstanceCore(RuntimeInstanceCore&& other) noexcept;
    RuntimeInstanceCore& operator=(RuntimeInstanceCore&& other) noexcept;
 
    [[nodiscard]] const InstanceIdentity& identity() const noexcept { return identity_; }
    [[nodiscard]] void* state() noexcept { return state_; }
    [[nodiscard]] const void* state() const noexcept { return state_; }
    [[nodiscard]] bool isActive() const noexcept { return active_; }
    void setActive(bool active) noexcept { active_ = active; }
 
    [[nodiscard]] eve::Result<void> checkDefinition(const DefinitionHandle& handle) const;
 
    [[nodiscard]] eve::Result<ReloadOutcome> reload(const DefinitionHandle& next, ReloadPolicy policy,
                                                    const void* defaults, const RebuildFunction& rebuild);
 
    [[nodiscard]] eve::Result<void> restoreExact(const InstanceIdentity& identity, void* state, bool active);
 
private:
    InstanceIdentity identity_;
    void*            state_   = nullptr;
    CloneFunction    clone_   = nullptr;
    AssignFunction   assign_  = nullptr;
    DestroyFunction  destroy_ = nullptr;
    bool             active_  = true;
};
 
template <class State>
[[nodiscard]] void* cloneRuntimeState(const void* state) {
    return new State(*static_cast<const State*>(state));
}
 
template <class State>
void assignRuntimeState(void* destination, const void* source) {
    *static_cast<State*>(destination) = *static_cast<const State*>(source);
}
 
template <class State>
void destroyRuntimeState(void* state) noexcept {
    delete static_cast<State*>(state);
}
 
template <class State>
class RuntimeInstance {
    static_assert(std::is_copy_constructible_v<State>, "RuntimeInstance state must be copy constructible");
 
public:
    using RebuildFunction =
        std::function<eve::Result<State>(const State&, const InstanceIdentity&, const DefinitionHandle&)>;
 
private:
    RuntimeInstance(InstanceIdentity identity, State state, bool active = true)
        : core_(std::move(identity), new State(std::move(state)), &cloneRuntimeState<State>, &assignRuntimeState<State>,
                &destroyRuntimeState<State>, active) {}
 
public:
    RuntimeInstance(const RuntimeInstance&) = default;
    RuntimeInstance& operator=(const RuntimeInstance&) = default;
    RuntimeInstance(RuntimeInstance&&) noexcept = default;
    RuntimeInstance& operator=(RuntimeInstance&&) noexcept = default;
    ~RuntimeInstance() = default;
 
    [[nodiscard]] static eve::Result<RuntimeInstance> create(eve::PersistentId  instanceId,
                                                             eve::DefinitionRef definition,
                                                             eve::Generation definitionGeneration, State state,
                                                             bool active = true) {
        auto identity = InstanceIdentity::create(instanceId, std::move(definition), definitionGeneration);
        if (!identity) return eve::Result<RuntimeInstance>::failure(identity.status());
        return eve::Result<RuntimeInstance>::success(
            RuntimeInstance(std::move(identity).takeValue(), std::move(state), active));
    }
 
    [[nodiscard]] const InstanceIdentity& identity() const noexcept { return core_.identity(); }
    [[nodiscard]] const State& state() const noexcept { return *static_cast<const State*>(core_.state()); }
    [[nodiscard]] State& state() noexcept { return *static_cast<State*>(core_.state()); }
    [[nodiscard]] bool isActive() const noexcept { return core_.isActive(); }
    void setActive(bool active) noexcept { core_.setActive(active); }
 
    [[nodiscard]] eve::Result<void> checkDefinition(const DefinitionHandle& handle) const {
        return core_.checkDefinition(handle);
    }
 
    [[nodiscard]] eve::Result<ReloadOutcome> reload(const DefinitionHandle& next, ReloadPolicy policy,
                                                    const State& defaults, RebuildFunction rebuild = {}) {
        RuntimeInstanceCore::RebuildFunction erased;
        if (rebuild) {
            erased = [callback = std::move(rebuild)](const void* state, const InstanceIdentity& identity,
                                                     const DefinitionHandle& handle) -> eve::Result<void*> {
                auto rebuilt = callback(*static_cast<const State*>(state), identity, handle);
                if (!rebuilt) return eve::Result<void*>::failure(rebuilt.status());
                return eve::Result<void*>::success(new State(std::move(rebuilt).takeValue()));
            };
        }
        return core_.reload(next, policy, &defaults, erased);
    }
 
    [[nodiscard]] eve::Result<void> restoreExact(const InstanceIdentity& identity, State state, bool active) {
        return core_.restoreExact(identity, new State(std::move(state)), active);
    }
 
private:
    RuntimeInstanceCore core_;
};
 
}  // namespace eve::definition