Object.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/SharedPtr.hpp"
#include "AstUtil/ScopedPtr.hpp"
#include "AstUtil/ReflectAPI.hpp"
#include <string>       // for std::string
#include <stdint.h>     // for uint32_t
#include <assert.h>     // for assert
#include <atomic>       // for std::atomic
 
AST_NAMESPACE_BEGIN
 
 
class Class;        // 类元信息
class Property;     // 属性元信息
 
template<typename _Object>
class WeakPtr;
 
template<typename ObjectPtrType, typename PropertyType>
class AttributeBasic;
 
typedef AttributeBasic<WeakPtr<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, 
};
 
struct initial_strong_ref_t {};                      
constexpr initial_strong_ref_t initial_strong_ref{}; 
 
 
class AST_UTIL_API Object
{
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);
    
    Object()
        : refcnt_{0}
        , weakrefcnt_{1}
    {}
    explicit Object(Object* parentScope);
    Object(std::nullptr_t);
    
    Object(initial_strong_ref_t)
        : refcnt_{1}
        , weakrefcnt_{1}
    {}
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();}
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;
 
    bool isOfType(const Class* type) const;
 
    bool isOfType(StringView typeName) const;
 
    template<typename T>
    bool isOfType() const;
 
public: // 引用计数
    uint32_t refCount() const{return refcnt_;}
 
    uint32_t weakRefCount() const{return weakrefcnt_;}
 
    bool     isDestructed() const{return aObject_IsDestructed(this);}
 
    void     destruct()
    {
        #ifndef NDEBUG
        if(refcnt_ != 0)
        {
            printf("object ref count is not 0, can not destruct");
        }
        #endif
        assert(refcnt_ == 0);  // 只能直接删除不采用共享引用计数管理的对象
        this->_destruct();
    }
 
    uint32_t incWeakRef()
    {
        return aObject_IncWeakRef(this);
    }
 
    uint32_t decWeakRef()
    {
        return aObject_DecWeakRef(this);
    }
 
    uint32_t incRef()
    {
        return aObject_IncRef(this);
    }
 
    uint32_t decRef()
    {
        return aObject_DecRef(this);
    }
 
    uint32_t decRefNoDelete()
    {
        return --refcnt_;
    }
private:
    void    _destruct()
    {
        this->~Object();
        this->decWeakRef();
    }
public: // 延迟链接
    template<typename Func>
    inline void addDelayedLink(Func &&link);
 
 
    template<typename Func>
    inline void addDelayedLinkIfFailed(Func &&link);
 
    void resolveLinks();
 
protected:
    friend class ObjectManager;
    virtual ~Object();
    Object(const Object& obj)
        : Object()
    {}
    Object& operator=(const Object&)
    {
        return *this;
    }
public: // 实参依赖查找（ADL）
    A_ALWAYS_INLINE 
    friend uint32_t aObject_IncRef(Object* obj)
    {
        return ++(obj->refcnt_);
    }
    A_ALWAYS_INLINE 
    friend uint32_t aObject_DecRef(Object* obj)
    {
        if (obj->refcnt_ == 1) {
            obj->_destruct();
            return 0;
        }
        return --(obj->refcnt_);
    }
    A_ALWAYS_INLINE 
    friend uint32_t aObject_IncWeakRef(Object* obj)
    {
        return ++(obj->weakrefcnt_);
    }
    A_ALWAYS_INLINE 
    friend uint32_t aObject_DecWeakRef(Object* obj)
    {
        if (obj->weakrefcnt_ == 1) {
            operator delete(obj);
            return 0;
        }
        else {
            return --(obj->weakrefcnt_);
        }
    }
    A_ALWAYS_INLINE 
    friend bool aObject_IsDestructed(const Object *obj)
    {
        return obj->refcnt_ == static_cast<uint32_t>(-1);
    }
 
private:
    // Class*                type_;                                     ///< 类型元信息，同时用于标识对象是否被析构(废弃，采用虚函数`getType()`实现)
    std::atomic<uint32_t>    refcnt_{0};                                
    std::atomic<uint32_t>    weakrefcnt_{1};                            
    uint32_t                 index_{static_cast<uint32_t>(INVALID_ID)}; 
    // uint32_t                 flags_{0};                                 ///< 对象标志位，用于存储对象的额外信息
};
 
// 定义：检测 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>
T aobject_cast(Object* obj)
{
    using ObjectType = typename std::decay<typename std::remove_pointer<T>::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());
}
 
AST_NAMESPACE_END
 
AST_DECL_TYPE_ALIAS(Object)
 
#include "AstUtil/Attribute.hpp"
#include "AstUtil/Class.hpp"
#include "AstUtil/WeakPtr.hpp"