DefinitionTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditingAuthority.h"
#include "editing/EditableTarget.h"
 
#include <functional>
#include <string>
#include <vector>
 
namespace eve::definitions {
class DefinitionRegistry;
}
 
namespace eve::definitions_editing {
 
using namespace eve::editing;
using EditorValue = eve::editing::Value;
using EditorStatus = eve::editing::Status;
using EditorDiagnostic = eve::editing::Diagnostic;
using editing::Result;
 
struct DefinitionReferenceField {
    std::string path;
    std::string type;
    std::string id;
    bool required = true;
};
 
class EVENGINE_API_BACKENDS DefinitionDocument : public ::eve::editing::EditableTargetState,
                                                 public virtual IEditableTarget,
                                                 public IDomainOperationTarget {
public:
    using ReferenceResolver = std::function<bool(const std::string& type, const std::string& id)>;
    using SchemaValidator = std::function<std::vector<EditorDiagnostic>(const std::string& type,
                                                                        int version,
                                                                        const std::string& json)>;
 
    DefinitionDocument(std::string type, std::string id, int version = 1);
    TargetId         targetId() const override { return TargetId(targetId_); }
    TargetDescriptor describe() const override;
    void* queryCapability(const CapabilityId&) override { return nullptr; }
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    Result<void> setJson(std::string json);
    Result<void> setVersion(int version);
    Result<void> setReferences(std::vector<DefinitionReferenceField> references);
    Result<DomainOperation> makeSetField(const std::string& field,
                                               const EditorValue& value) const;
    std::vector<EditorDiagnostic> validate(const SchemaValidator& schema,
                                           const ReferenceResolver& references) const;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
    const std::string& type() const { return type_; }
    const std::string& id() const { return id_; }
    int version() const { return version_; }
    const std::string& json() const { return json_; }
    editing::Revision documentRevision() const { return revisionValue(); }
 
private:
    std::string type_;
    std::string id_;
    std::string targetId_;
    int version_ = 1;
    std::string json_ = "{}";
    std::vector<DefinitionReferenceField> references_;
};
 
class EVENGINE_API_BACKENDS DefinitionRuntimePublisher {
public:
    Result<void> publish(const DefinitionDocument& document,
                               definitions::DefinitionRegistry* registry,
                               bool replaceExisting = false) const;
};
 
}  // namespace eve::definitions_editing