StepKindRegistry.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/Value.h"
#include "dnut_interpreter/SequenceAsset.h"
 
#include <functional>
#include <map>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::dnut {
 
enum class StepShape : std::uint8_t {
    Instant,
    Await,
};
 
enum class StepFieldType : std::uint8_t { String, Number, Integer, Boolean, Any };
 
struct StepField {
    std::string   name;
    StepFieldType type     = StepFieldType::String;
    bool          required  = false;
};
 
struct StepKindDescriptor {
    std::string            type;
    std::string            displayName;
    std::string            category;
    StepShape              shape = StepShape::Instant;
    std::vector<StepField> fields;
    std::function<eve::Result<void>(const SequenceNode& node)> validate;
};
 
enum class StepStatus : std::uint8_t { Completed, Blocked, Failed };
 
struct StepOutcome {
    StepStatus  status = StepStatus::Completed;
    std::string error;
    eve::Value  value;
};
 
struct StepContext {
    std::string       assetId;
    std::string       nodeId;
    const eve::Value* bindings = nullptr;
    const eve::Value* locals   = nullptr;
    void* host = nullptr;
};
 
using StepHandler = std::function<StepOutcome(const SequenceNode&, const StepContext&)>;
 
class EVENGINE_API_PLATFORM StepKindRegistry {
public:
    [[nodiscard]] eve::Result<void> registerStep(StepKindDescriptor descriptor);
 
    [[nodiscard]] eve::Result<void> registerHandler(std::string_view type, StepHandler handler);
 
    void unregisterStep(std::string_view type);
 
    [[nodiscard]] bool contains(std::string_view type) const;
 
    [[nodiscard]] const StepKindDescriptor* descriptor(std::string_view type) const;
 
    [[nodiscard]] std::vector<StepKindDescriptor> descriptors() const;
 
    [[nodiscard]] bool hasHandler(std::string_view type) const;
 
    [[nodiscard]] eve::Result<void> validate(const SequenceNode& node) const;
 
    [[nodiscard]] StepOutcome dispatch(const SequenceNode& node, const StepContext& context) const;
 
private:
    std::map<std::string, StepKindDescriptor, std::less<>> descriptors_;
    std::map<std::string, StepHandler, std::less<>>        handlers_;
};
 
[[nodiscard]] const char* stepShapeName(StepShape shape) noexcept;
 
}  // namespace eve::dnut