Object.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/SharedPtr.hpp"
#include "AstUtil/ScopedPtr.hpp"
#include "AstUtil/ReflectAPI.hpp"
#include "AstUtil/Referenced.hpp"
#include <type_traits>  // for std::decay, std::remove_pointer, std::remove_reference
#include <string>       // for std::string
#include <stdint.h>     // for uint32_t
 
AST_NAMESPACE_BEGIN
 
 
class Class;        // 类元信息
class Property;     // 属性元信息
 
template<typename _Object>
class WeakPtr;
 
template<typename ObjectPtrType, typename PropertyType>
class AttributeBasic;
 
typedef AttributeBasic<Object, Property> Attribute;
 
// AST 对象运行时元信息
#define AST_OBJECT(TYPE) \
    static Class staticType;\
    static inline Class* StaticType(){return &staticType;}\
    Class* getType() const override{return &staticType;} \
    static void ClassInit(Class* cls);\
 
// 定义属性
#define AST_PROPERT(NAME)   static constexpr const char* _prop_##NAME = #NAME;
 
// 获取属性名称
#define AST_PROPERT_NAME(CLASS, NAME) CLASS::_prop_##NAME
#define aPropertyName(CLASS, NAME) AST_PROPERT_NAME(CLASS, NAME)
 
#define _AST_IMPL_OBJECT(TYPE) \
    Class TYPE::staticType;\
 
 
enum {
    INVALID_ID = -1, 
};
 
enum class EObjectFlags: uint32_t
{
    eNone = 0,              
    eReadOnly = 0x01,       
    eInActive = 0x02,       
    eComponent = 0x04,      
    eEntity = 0x08,         
};
 
 
A_ENUM_CLASS_FLAGS(EObjectFlags)
 
 
class AST_UTIL_API Object: public Referenced
{
public:
    static Object* Resolve(StringView value);
    
    // friend uint32_t aObject_IncRef(Object* obj);
    // friend uint32_t aObject_DecRef(Object* obj);
    // friend uint32_t aObject_IncWeakRef(Object* obj);
    // friend uint32_t aObject_DecWeakRef(Object* obj);
    // friend bool aObject_IsDestructed(const Object* obj);
    
    using Referenced::Referenced;
    Object() = default;
    explicit Object(Object* parentScope);
    Object(std::nullptr_t);
    
 
public:
    static Class staticType;
    static void ClassInit(Class* cls);
    static inline Class* StaticType(){return &staticType;}
 
    virtual Class* getType() const;
 
    virtual std::string getRepresentation() const;
 
    virtual const std::string& getName() const;
 
    virtual void setName(StringView name) = 0;
 
    const std::string& name() const {return this->getName();}
 
    std::string displayName() const;
public: // 编辑属性
    
    errc_t showEditDialog();
 
public: // 通用属性访问
    Attribute attr(StringView path);
 
public: // 获取属性
    errc_t getAttrBool(StringView path, bool& value) const;
    
    errc_t getAttrInt(StringView path, int& value) const;
 
    errc_t getAttrDouble(StringView path, double& value) const;
 
    errc_t getAttrString(StringView path, std::string& value) const;
 
 
    errc_t getAttrObject(StringView path, Object*& value) const;
 
public: // 获取属性值
    double getAttrDouble(StringView path) const;
 
    int getAttrInt(StringView path) const;
 
    bool getAttrBool(StringView path) const;
 
    std::string getAttrString(StringView path) const;
 
 
    Object* getAttrObject(StringView path) const;
 
public: // 设置属性值
    errc_t setAttrBool(StringView path, bool value);
 
    errc_t setAttrInt(StringView path, int value);
 
    errc_t setAttrDouble(StringView path, double value);
 
    errc_t setAttrString(StringView path, StringView value);
 
 
    errc_t setAttrObject(StringView path, Object* value);
 
public: // 类型与字段属性
    Class* type() const{return getType();} // 转发到新接口getType
 
    const std::string& typeName() const;
 
    Property* getProperty(StringView fieldName) const;
public: // 对象ID
 
    ObjectId getID() const;
 
    errc_t setParentScope(Object* parentScope);
 
    Object* getParentScope() const;
 
    template<typename T>
    T getParent() const;
 
    bool isOfType(const Class* type) const;
 
    bool isOfType(StringView typeName) const;
 
    template<typename T>
    bool isOfType() const;
public: // 延迟链接
    template<typename Func>
    inline void addDelayedLink(Func &&link);
 
 
    template<typename Func>
    inline void addDelayedLinkIfFailed(Func &&link);
 
    void resolveLinks();
public:  // 对象标志位
    bool readOnly() const {return !!(flags_ & EObjectFlags::eReadOnly);}
    void setReadOnly(bool readOnly);
 
    bool active() const {return !(flags_ & EObjectFlags::eInActive);}
    void setActive(bool active);
    
    bool isComponent() const {return !!(flags_ & EObjectFlags::eComponent);}
    void setIsComponent(bool isComponent);
 
    bool isEntity() const {return !!(flags_ & EObjectFlags::eEntity);}
    void setIsEntity(bool isEntity);
    
public: // 国际化
    const char* tr(const char* msg) const;
protected:
    friend class ObjectManager;
    virtual ~Object();
    Object(const Object& obj)
        : Object()
    {}
    Object& operator=(const Object&)
    {
        return *this;
    }
private:
    // Class*                type_;                                     ///< 类型元信息，同时用于标识对象是否被析构(废弃，采用虚函数`getType()`实现)
    uint32_t                 index_{static_cast<uint32_t>(INVALID_ID)}; 
    EObjectFlags             flags_{};                                  
};
 
// 定义：检测 T 是否拥有 “Class* (T::*)() const” 签名的成员函数 getType
template <typename T>
struct has_own_getType {
private:
    typedef char yes;
    typedef long no;
 
    // 仅当 U 具有 Class* (U::*)() const 的成员时，此辅助模板才能实例化
    template <typename U, Class* (U::*)() const>
    struct Check;
 
    // 如果能匹配 &U::getType，则返回 yes
    template <typename U>
    static yes test(Check<U, &U::getType>*);
 
    // 否则走 ...
    template <typename>
    static no test(...);
 
public:
    static constexpr bool value = (sizeof(test<T>(0)) == sizeof(yes));
};
 
 
template<typename T, typename U>
A_ALWAYS_INLINE T aobject_cast(U* obj)
{
    // obj 可以是 Object* 或 const Object*
    using ObjectType = typename std::decay<
        typename std::remove_pointer<
            typename std::remove_pointer<T>::type
        >::type
    >::type;
    static_assert(has_own_getType<ObjectType>::value,
                  "aobject_cast requires the type to has a AST_OBJECT macro");
    return static_cast<T>(ObjectType::StaticType()->cast(obj));
}
 
 
template<typename T>
bool Object::isOfType() const
{
    using ObjectType = typename std::decay<typename std::remove_pointer<T>::type>::type;
    static_assert(has_own_getType<ObjectType>::value, "isOfType requires the type to has a AST_OBJECT macro");
    return isOfType(ObjectType::StaticType());
}
 
template<typename T>
T Object::getParent() const
{
    return aobject_cast<T>(getParentScope());
}
 
template<typename T>
SharedPtr<T> aMakeShared()
{
    return new T();
}
 
template<typename T>
SharedPtr<T> aMakeShared(Object* parentScope)
{
    T* obj = new T();
    aSetParentScope(obj, parentScope);
    return obj;
}
 
template<typename T>
SharedPtr<T> aMakeShared(StringView objectName)
{
    T* obj = new T();
    obj->setName(objectName);
    return obj;
}
 
template<typename T>
SharedPtr<T> aMakeShared(Object* parentScope, StringView typeName)
{
    T* obj = new T();
    obj->setParentScope(parentScope);
    obj->setName(typeName);
    return obj;
}
 
 
template<typename T>
T* aNewObject(Object* parentScope=nullptr)
{
    T* obj = new T();
    obj->setParentScope(parentScope);
    return obj;
}
 
template<typename T>
T* aNewObject(StringView objectName)
{
    T* obj = new T();
    obj->setName(objectName);
    return obj;
}
 
template<typename T>
T* aNewObject(Object* parentScope, StringView objectName)
{
    T* obj = new T();
    obj->setParentScope(parentScope);
    obj->setName(objectName);
    return obj;
}
 
AST_NAMESPACE_END
 
AST_DECL_TYPE_ALIAS(Object)
 
#include "AstUtil/Attribute.hpp"
#include "AstUtil/Class.hpp"
#include "AstUtil/WeakPtr.hpp"