EditorDocumentService.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditorProtocol.h"
 
#include <functional>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::editor {
 
enum class DocumentKind {
    Scene,
    Prefab,
    Material,
    MaterialFunction,
    MaterialInstance,
    AnimationClip,
    AnimationGraph,
    ParticleGraph,
    UiDocument,
    Timeline,
    ProjectSettings,
    ImportSettings,
    Generic
};
 
struct DocumentKey {
    DocumentKind kind = DocumentKind::Generic;
    AssetGuid    asset;
 
    auto operator<=>(const DocumentKey&) const = default;
};
 
enum class DocumentState { Loading, Ready, Saving, Conflict, Failed, Closed };
 
struct DocumentRevision {
    Revision edit    = 0;
    Revision saved   = 0;
    Revision disk    = 0;
    Revision preview = 0;
};
 
struct DocumentSnapshot {
    DocumentId                    id;
    DocumentKey                   key;
    std::string                   title;
    std::string                   resourceUri;
    DocumentState                 state = DocumentState::Loading;
    DocumentRevision              revision;
    std::string                   diskContentHash;
    std::vector<StableId>         viewIds;
    std::vector<EditorDiagnostic> diagnostics;
 
    bool dirty() const { return revision.edit != revision.saved; }
};
 
struct SaveTicket {
    StableId    id;
    DocumentId  document;
    Revision    capturedEditRevision = 0;
    Revision    expectedDiskRevision = 0;
    std::string expectedContentHash;
};
 
struct StoredDocument {
    EditorValue content;
    Revision    revision = 0;
    std::string contentHash;
};
 
class IAtomicDocumentStore {
public:
    virtual ~IAtomicDocumentStore() = default;
    virtual Result<StoredDocument> read(const std::string& resourceUri) const = 0;
    virtual Result<StoredDocument> compareAndSwap(const std::string& resourceUri, Revision expectedRevision,
                                                        const std::string& expectedContentHash,
                                                        const EditorValue& content) = 0;
};
 
class EVENGINE_API_ORCHESTRATION MemoryAtomicDocumentStore final : public IAtomicDocumentStore {
public:
    Result<StoredDocument> read(const std::string& resourceUri) const override;
    Result<StoredDocument> compareAndSwap(const std::string& resourceUri, Revision expectedRevision,
                                                const std::string& expectedContentHash,
                                                const EditorValue& content) override;
 
private:
    std::unordered_map<std::string, StoredDocument> documents_;
};
 
class EVENGINE_API_ORCHESTRATION DocumentService {
public:
    using ContentValidator = std::function<Result<void>(const EditorValue&)>;
 
    explicit DocumentService(IAtomicDocumentStore* store) : store_(store) {}
 
    Result<DocumentSnapshot> open(DocumentKey key, std::string title, std::string resourceUri,
                                        EditorValue initialContent = {});
    Result<DocumentSnapshot> edit(const DocumentId& document, EditorValue content,
                                        std::optional<Revision> expectedRevision = std::nullopt);
    Result<SaveTicket> requestSave(const DocumentId& document);
    Result<DocumentSnapshot> executeSave(const SaveTicket& ticket);
    Result<EditorValue> content(const DocumentId& document) const;
    Result<DocumentSnapshot> snapshot(const DocumentId& document) const;
    std::vector<DocumentSnapshot> documents() const;
    Result<DocumentSnapshot> reconcileExternal(const DocumentId& document);
    Result<DocumentSnapshot> reconcileExternal(const DocumentId& document, ContentValidator validator);
    Result<void> close(const DocumentId& document);
 
private:
    struct OpenDocument {
        DocumentSnapshot snapshot;
        EditorValue      content;
    };
    struct PendingSave {
        SaveTicket  ticket;
        EditorValue content;
    };
 
    static Result<DocumentSnapshot> error(EditorStatus status, const char* rule, std::string message);
 
    IAtomicDocumentStore*                                                        store_ = nullptr;
    std::unordered_map<DocumentId, OpenDocument, StrongEditorIdHash<DocumentId>> open_;
    std::unordered_map<StableId, PendingSave, StrongEditorIdHash<StableId>>      pendingSaves_;
    std::uint64_t                                                                ticketSequence_ = 0;
};
 
}  // namespace eve::editor