Object.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/SharedPtr.hpp"
#include "AstUtil/ScopedPtr.hpp"
#include "AstUtil/WeakPtr.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 ObjectPtrType, typename PropertyType>
class AttributeBasic;
 
typedef AttributeBasic<WeakPtr<Object>, Property> Attribute;
 
// AST 对象运行时元信息
#define AST_OBJECT(TYPE) \
    static Class staticType;\
    static inline Class* getStaticType(){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, 
};
 
 
class AST_UTIL_API Object
{
public:
    Object()
        : refcnt_{0}
        , weakrefcnt_{1}
    {}
    Object(Object* parentScope);
    Object(std::nullptr_t);
public:
    static Class staticType;
    static inline Class* getStaticType(){return &staticType;}
 
    virtual Class* getType() const;
 
    virtual const std::string& getName() const;
 
 
public: // 编辑属性
    
    errc_t openEditDialog();
 
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;
 
public: // 获取属性值
    double getAttrDouble(StringView path) const;
 
    int getAttrInt(StringView path) const;
 
    bool getAttrBool(StringView path) const;
 
    std::string getAttrString(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);
 
public: // 类型与字段属性
    Class* type() const{return getType();} // 转发到新接口getType
 
    Property* getProperty(StringView fieldName) const;
public: // 对象ID
 
    uint32_t getID() const;
 
    errc_t setParentScope(Object* parentScope);
 
    Object* getParentScope() const;
public: // 引用计数
    uint32_t refCount() const{return refcnt_;}
 
    uint32_t weakRefCount() const{return weakrefcnt_;}
 
    bool     isDestructed() const{return refcnt_ == static_cast<uint32_t>(-1);}
 
    void     destruct()
    {
        assert(refcnt_ == 0);  // 只能直接删除不采用共享引用计数管理的对象
        this->_destruct();
    }
 
    uint32_t incWeakRef()
    {
        return ++weakrefcnt_;
    }
 
    uint32_t decWeakRef()
    {
        if (weakrefcnt_ == 1) {
            operator delete(this);
            return 0;
        }
        else {
            return --weakrefcnt_;
        }
    }
 
    uint32_t incRef()
    {
        return ++refcnt_;
    }
 
    uint32_t decRef()
    {
        if (refcnt_ == 1) {
            this->_destruct();
            return 0;
        }
        return --refcnt_;
    }
 
    uint32_t decRefNoDelete()
    {
        return --refcnt_;
    }
private:
    void    _destruct()
    {
        this->~Object();
        this->refcnt_ = static_cast<uint32_t>(-1); // 标识对象是否被析构. bit mask indicate whether object is destructed.
        this->decWeakRef();
    }
 
protected:
    friend class ObjectManager;
    virtual ~Object();
    Object(const Object& obj)
        : refcnt_(0)
        , weakrefcnt_(1)
    {}
    Object& operator=(const Object& obj)
    {
        A_UNUSED(obj);
        return *this;
    }
private:
    // Class*                type_;                                     ///< 类型元信息，同时用于标识对象是否被析构(废弃)
    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};                                 
};
 
 
AST_NAMESPACE_END
 
AST_DECL_TYPE_ALIAS(Object)
 
#include "AstUtil/Attribute.hpp"
#include "AstUtil/Class.hpp"