PropertyAccess.h

浏览该文件的文档.

#pragma once
 
#include "common/BorrowedRef.h"
#include "common/Export.h"
#include "common/Subscription.h"
#include "common/Value.h"
 
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::property_access {
 
enum class PropertyKind {
    Auto,
    Bool,
    Integer,
    Number,
    String,
    Enum,
    Color,
    Vec2,
    Vec3,
    Vec4,
    AssetRef,
    ObjectRef,
    Struct,
    Array,
    Map,
    Action,
    ReadOnlyText
};
 
enum class PropertyFlag : std::uint64_t {
    None       = 0,
    ReadOnly   = 1ull << 0,
    Advanced   = 1ull << 1,
    EditorOnly = 1ull << 2,
    Runtime    = 1ull << 3,
    Transient  = 1ull << 4,
    Dangerous  = 1ull << 5,
    MultiEdit  = 1ull << 6
};
 
constexpr PropertyFlag operator|(PropertyFlag left, PropertyFlag right) {
    return static_cast<PropertyFlag>(static_cast<std::uint64_t>(left) | static_cast<std::uint64_t>(right));
}
constexpr PropertyFlag operator&(PropertyFlag left, PropertyFlag right) {
    return static_cast<PropertyFlag>(static_cast<std::uint64_t>(left) & static_cast<std::uint64_t>(right));
}
constexpr bool hasFlag(PropertyFlag value, PropertyFlag flag) { return (value & flag) == flag; }
 
struct NumericMetadata {
    std::optional<double> minimum;
    std::optional<double> maximum;
    std::optional<double> step;
    std::string           units;
    int                   precision = 3;
};
 
struct PropertyDescriptor {
    std::string              path;
    std::string              displayName;
    std::string              description;
    std::string              category;
    PropertyKind             kind  = PropertyKind::Auto;
    PropertyFlag             flags = PropertyFlag::None;
    Value                    defaultValue;
    NumericMetadata          numeric;
    std::vector<std::string> choices;
    std::string              presenterHint;
};
 
struct EVENGINE_API_FOUNDATION PropertySchema {
    std::string                     typeId;
    std::uint32_t                   version = 1;
    std::vector<PropertyDescriptor> properties;
 
    [[nodiscard]] eve::OptionalRef<const PropertyDescriptor> find(const std::string &path) const;
};
 
struct WriteResult {
    bool        accepted = false;
    std::string code;
    std::string message;
 
    static WriteResult success() { return {true, {}, {}}; }
    static WriteResult reject(std::string code, std::string message) {
        return {false, std::move(code), std::move(message)};
    }
};
 
EVENGINE_API_FOUNDATION WriteResult validatePropertyValue(const PropertyDescriptor &property, const Value &value);
 
enum class PropertyChangeState { Value, Mixed, Missing };
 
struct PropertyChange {
    std::string   path;
    Value         value;
    std::uint64_t revision = 0;
    PropertyChangeState state = PropertyChangeState::Value;
};
 
using Subscription = eve::Subscription;
 
class EVENGINE_API_FOUNDATION_INLINE IPropertyAccess {
public:
    using ChangeCallback = std::function<void(const PropertyChange &)>;
 
    virtual ~IPropertyAccess() = default;
    virtual const PropertySchema &schema() const = 0;
    virtual std::optional<Value> read(const std::string &path) const = 0;
    virtual WriteResult write(const std::string &path, const Value &value) = 0;
    virtual std::uint64_t revision() const = 0;
    virtual Subscription subscribe(ChangeCallback callback) = 0;
};
 
}  // namespace eve::property_access