EditableTarget.h

浏览该文件的文档.

#pragma once
#include <string>
#include <type_traits>
#include <vector>
#include "common/BorrowedRef.h"
#include "editing/EditingProtocol.h"
namespace eve::editing {
struct EditRegion {
    int  minX = 0, minY = 0, maxX = -1, maxY = -1;
    bool empty() const { return maxX < minX || maxY < minY; }
    void clear() { *this = {}; }
    void include(int x, int y) {
        if (empty()) {
            minX = maxX = x;
            minY = maxY = y;
            return;
        }
        if (x < minX) minX = x;
        if (x > maxX) maxX = x;
        if (y < minY) minY = y;
        if (y > maxY) maxY = y;
    }
    void include(const EditRegion& o) {
        if (!o.empty()) {
            include(o.minX, o.minY);
            include(o.maxX, o.maxY);
        }
    }
};
 
struct TargetDescriptor {
    TargetId                  id;
    std::string               type;
    Revision                  revision = 0;
    bool                      readOnly = false;
    std::vector<CapabilityId> capabilities;
};
 
class IEditableTarget {
public:
    virtual ~IEditableTarget()                     = default;
    virtual TargetId           targetId() const    = 0;
    virtual std::uint64_t      revision() const    = 0;
    virtual EditRegion         dirtyRegion() const = 0;
    virtual void               clearDirtyRegion()  = 0;
    virtual TargetDescriptor describe() const {
        return {targetId(), {}, revision(), false, {}};
    }
    virtual void* queryCapability(const CapabilityId& capability) {
        (void)capability;
        return nullptr;
    }
    template <class C>
    eve::OptionalRef<C> capability() {
        if constexpr (requires { C::editingCapabilityId(); }) {
            if (void* raw = queryCapability(C::editingCapabilityId()))
                return eve::OptionalRef<C>(std::ref(*static_cast<C*>(raw)));
        }
        if constexpr (std::is_polymorphic_v<C>) {
            if (auto* typed = dynamic_cast<C*>(this)) return eve::OptionalRef<C>(std::ref(*typed));
        }
        return {};
    }
    template <class C>
    eve::OptionalRef<const C> capability() const {
        if constexpr (std::is_polymorphic_v<C>) {
            if (auto* typed = dynamic_cast<const C*>(this)) return eve::OptionalRef<const C>(std::ref(*typed));
        }
        return {};
    }
    template <class C>
    C* query() {
        auto cap = capability<C>();
        return cap ? &cap->get() : nullptr;
    }
    template <class C>
    const C* query() const {
        auto cap = capability<C>();
        return cap ? &cap->get() : nullptr;
    }
};
#if defined(_MSC_VER)
// A target that inherits this base together with another editing interface that
// also derives from IEditableTarget (IDomainOperationTarget, for example) receives
// the three members below through dominance instead of declaring them itself, and
// MSVC reports C4250 for each such member. That resolution is well-defined and is
// the intent: these overrides are the final overriders, so every call through
// IEditableTarget dispatches here. MSVC documents C4250 as informational, and it is
// disabled at the single class that creates the pattern because MSVC reports it at
// each derived class -- which lives in a header that includes this one, after this
// point, so the suppression below covers them.
#pragma warning(disable : 4250)
#endif
class EditableTargetState : public virtual IEditableTarget {
public:
    explicit EditableTargetState(Revision initial = 1) : revision_(initial) {}
 
    [[nodiscard]] EditRegion dirtyRegion() const override { return dirty_; }
 
    void clearDirtyRegion() override { dirty_ = {}; }
 
    [[nodiscard]] std::uint64_t revision() const override { return revision_; }
 
    [[nodiscard]] Revision revisionValue() const noexcept { return revision_; }
 
protected:
    void widenDirty(int x, int y) { dirty_.include(x, y); }
    void widenDirty(const EditRegion& region) { dirty_.include(region); }
    void widenDirty() { dirty_.include(0, 0); }
    void bumpRevision() { ++revision_; }
    void setRevision(Revision revision) { revision_ = revision; }
    void setDirtyRegion(const EditRegion& region) { dirty_ = region; }
    void markDirty(int x, int y) {
        widenDirty(x, y);
        bumpRevision();
    }
    void markDirty(const EditRegion& region) {
        widenDirty(region);
        bumpRevision();
    }
    void markDirty() {
        widenDirty();
        bumpRevision();
    }
 
private:
    EditRegion dirty_;
    Revision   revision_;
};
enum class FieldWriteStatus { Applied, Unchanged, Rejected };
class IGridTarget {
public:
    virtual ~IGridTarget()                    = default;
    virtual int  width() const                = 0;
    virtual int  height() const               = 0;
    virtual bool containsCell(int, int) const = 0;
};
class IIntFieldTarget : public virtual IGridTarget {
public:
    static CapabilityId editingCapabilityId() { return CapabilityId("eve.editing.target.int-field.v1"); }
    virtual int  readInt(int, int) const = 0;
    [[nodiscard]] virtual FieldWriteStatus writeInt(int, int, int) = 0;
};
class IScalarFieldTarget : public virtual IGridTarget {
public:
    static CapabilityId editingCapabilityId() { return CapabilityId("eve.editing.target.scalar-field.v1"); }
    virtual float            readScalar(int, int) const       = 0;
    [[nodiscard]] virtual FieldWriteStatus writeScalar(int, int, float)     = 0;
    virtual float            sampleScalar(float, float) const = 0;
};
class IEditingSnapshotProvider {
public:
    virtual ~IEditingSnapshotProvider() = default;
    static CapabilityId editingCapabilityId() { return CapabilityId("eve.editing.target.snapshot.v1"); }
    [[nodiscard]] virtual Value snapshotValue() const = 0;
};
}  // namespace eve::editing