property.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_REFLECT_PROPERTY_HPP__
#define NEFORCE_CORE_REFLECT_PROPERTY_HPP__

 
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/string/string.hpp"
#include "NeForce/core/reflect/any.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_REFLECT__


enum property_attr : uint16_t {
    PROP_NONE = 0,           
    PROP_TRANSIENT = 1 << 0, 
    PROP_REQUIRED = 1 << 1,  
    PROP_READ_ONLY = 1 << 2, 
    PROP_OPTIONAL = 1 << 3,  
    PROP_VERSIONED = 1 << 4, 
 
    PROP_PRIMARY_KEY = 1 << 5, 
    PROP_AUTO_INC = 1 << 6,    
    PROP_UNIQUE = 1 << 7,      
    PROP_INDEX = 1 << 8,       
    PROP_FOREIGN_KEY = 1 << 9, 
};

NEFORCE_NODISCARD constexpr bool prop_has_attr(const uint16_t attrs, const property_attr flag) noexcept {
    return (attrs & static_cast<uint16_t>(flag)) != 0;
}

class meta_property {
public:
    using getter = function<meta_any(const void*)>;        
    using setter = function<void(void*, const meta_any&)>; 
 
private:
    string_view name_;           
    reflect::type_id type_id_;   
    getter getter_;              
    setter setter_;              
    uint16_t attrs_ = PROP_NONE; 
    uint32_t version_ = 0;       
    string notify_signal_name_;  
 
public:
    meta_property(string_view name, reflect::type_id type_id, getter getter, setter setter,
                  const uint16_t attrs = PROP_NONE) :
    name_(name),
    type_id_(type_id),
    getter_(move(getter)),
    setter_(move(setter)),
    attrs_(attrs) {}

    NEFORCE_NODISCARD string_view name() const noexcept { return name_; }

    NEFORCE_NODISCARD reflect::type_id type_id() const noexcept { return type_id_; }

    NEFORCE_NODISCARD uint16_t attributes() const noexcept { return attrs_; }

    void set_attributes(const uint16_t attrs) noexcept { attrs_ = attrs; }

    NEFORCE_NODISCARD bool is_transient() const noexcept { return prop_has_attr(attrs_, PROP_TRANSIENT); }

    NEFORCE_NODISCARD bool is_required() const noexcept { return prop_has_attr(attrs_, PROP_REQUIRED); }

    NEFORCE_NODISCARD bool is_readonly() const noexcept { return prop_has_attr(attrs_, PROP_READ_ONLY); }

    NEFORCE_NODISCARD bool is_optional() const noexcept { return prop_has_attr(attrs_, PROP_OPTIONAL); }

    NEFORCE_NODISCARD bool is_versioned() const noexcept { return prop_has_attr(attrs_, PROP_VERSIONED); }

    NEFORCE_NODISCARD bool is_primary_key() const noexcept { return prop_has_attr(attrs_, PROP_PRIMARY_KEY); }

    NEFORCE_NODISCARD bool is_auto_increment() const noexcept { return prop_has_attr(attrs_, PROP_AUTO_INC); }

    NEFORCE_NODISCARD bool is_unique() const noexcept { return prop_has_attr(attrs_, PROP_UNIQUE); }

    NEFORCE_NODISCARD bool is_index() const noexcept { return prop_has_attr(attrs_, PROP_INDEX); }

    NEFORCE_NODISCARD bool is_foreign_key() const noexcept { return prop_has_attr(attrs_, PROP_FOREIGN_KEY); }

    void set_notify_signal(string_view signal_name) { notify_signal_name_ = signal_name; }

    NEFORCE_NODISCARD string_view notify_signal() const noexcept { return notify_signal_name_.view(); }

    NEFORCE_NODISCARD bool has_notify_signal() const noexcept { return !notify_signal_name_.empty(); }

    NEFORCE_NODISCARD uint32_t version() const noexcept { return version_; }

    void set_version(const uint32_t ver) noexcept { version_ = ver; }

    NEFORCE_NODISCARD meta_any get(const void* obj) const {
        if (obj == nullptr || !getter_) {
            return meta_any{};
        }
        return getter_(obj);
    }

    bool set(void* obj, const meta_any& value) const {
        if (obj == nullptr || !setter_) {
            return false;
        }
        try {
            setter_(obj, value);
            return true;
        } catch (...) {
            return false;
        }
    }

    template <typename T, enable_if_t<!is_same_v<meta_any, decay_t<T>>, int> = 0>
    bool set(void* obj, T&& value) const {
        return this->set(obj, meta_any{_NEFORCE forward<T>(value)});
    }
};
 // Reflection
 
NEFORCE_END_REFLECT__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_REFLECT_PROPERTY_HPP__