EditorPropertyModel.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditorHostProfile.h"
#include "editor/EditorPropertyPresenter.h"
#include "property_access/PropertyAccess.h"
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
namespace eve::editor {
 
class IEditorTransactionBackend;
struct EditorDryRunReport;
 
enum class PropertyModelSurface { Developer, Runtime };
 
class EVENGINE_API_ORCHESTRATION EditorPropertyModel final : public property_access::IPropertyAccess {
public:
    using EditSink = std::function<Result<void>(const PropertyEditIntent &)>;
 
    EditorPropertyModel(PropertySchema schema, SelectionSnapshot selection, const IPropertyProvider *provider,
                        PropertyModelSurface       surface            = PropertyModelSurface::Developer,
                        HostProfile                profile            = HostProfile::developer(),
                        IEditorTransactionBackend *transactionBackend = nullptr);
    ~EditorPropertyModel() override;
 
    const property_access::PropertySchema     &schema() const override { return presentationSchema_; }
    std::optional<eve::Value>                  read(const std::string &path) const override;
    [[nodiscard]] property_access::WriteResult write(const std::string &path, const eve::Value &value) override;
    std::uint64_t revision() const override { return revision_; }
    property_access::Subscription              subscribe(ChangeCallback callback) override;
 
    [[nodiscard]] eve::Revision targetRevision() const noexcept { return targetRevision_; }
 
    [[nodiscard]] Result<void> bind();
 
    [[nodiscard]] Result<void> setTransactionBackend(IEditorTransactionBackend *backend);
 
    [[nodiscard]] Result<TransactionId> beginTransaction(std::string label = "Edit property");
    [[nodiscard]] Result<EditorDryRunReport> previewTransaction();
    [[nodiscard]] Result<TransactionReceipt> commitTransaction();
    [[nodiscard]] Result<void> rollbackTransaction();
    [[nodiscard]] Result<TransactionReceipt> retryTransaction();
    [[nodiscard]] Result<TransactionReceipt> undo();
    [[nodiscard]] Result<TransactionReceipt> redo();
 
    void setEditSink(EditSink sink) { sink_ = std::move(sink); }
    [[nodiscard]] Result<void> refresh();
 
    [[nodiscard]] Result<void> rebase();
 
private:
    struct CachedProperty {
        property_access::PropertyChangeState state = property_access::PropertyChangeState::Missing;
        std::optional<eve::Value>             value;
 
        bool operator==(const CachedProperty &) const = default;
    };
 
    struct ObserverState;
    void rebuildSchema();
    void                                      dispatch(std::vector<property_access::PropertyChange> changes);
    [[nodiscard]] Result<eve::Revision> readProviderRevision() const;
    [[nodiscard]] Result<void>          ensureCurrentRevision() const;
 
    PropertySchema editorSchema_;
    SelectionSnapshot selection_;
    const IPropertyProvider *provider_ = nullptr;
    PropertyModelSurface surface_ = PropertyModelSurface::Developer;
    HostProfile profile_;
    property_access::PropertySchema   presentationSchema_;
    std::map<std::string, CachedProperty> cachedProperties_;
    EditSink sink_;
    IEditorTransactionBackend        *transactionBackend_ = nullptr;
    std::set<std::string>             pendingPaths_;
    eve::Revision                     targetRevision_;
    bool                              bound_    = false;
    std::uint64_t revision_ = 0;
    std::shared_ptr<ObserverState> observers_;
    std::vector<std::vector<property_access::PropertyChange>> notificationQueue_;
    bool dispatchingNotifications_ = false;
};
 
}  // namespace eve::editor