Class.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/Struct.hpp"
#include "AstUtil/SharedPtr.hpp"
#include "AstUtil/Object.hpp"
#include <type_traits>
 
AST_NAMESPACE_BEGIN
 
class Object;
 
 
 
class AST_UTIL_API Class: public Struct
{
public:
    typedef Object* (*FConstructor)(Object* parentScope);
    typedef Object* (*FResolve)(StringView value);
 
    AST_OBJECT(Class);
 
    using Struct::Struct;
 
    Class(const Class&) = default;
    Class& operator=(const Class&) = default;
 
    explicit Class(Class* parent = nullptr);
 
    
    ~Class();
 
    Object* cast(Object* obj) const;
    const Object* cast(const Object* obj) const;
 
    bool isVirtual() const{return constructor_ == nullptr;}
 
    Class* getParent() const{ return parent_; }
 
    void addToRegistry() const;
 
    Object* newObject(Object* parentScope) const;
 
    Object* resolve(StringView value) const;
 
    Object* getDefaultObject() const;
public:
 
    void setParent(Class* parent){ parent_ = parent; }
    
    void setConstructor(FConstructor constructor){ constructor_ = constructor; }
 
    void setResolve(FResolve resolve){ resolve_ = resolve; }
 
    template<typename T>
    void setParent()
    {
        //setParent(T::StaticType());
        setParent(&T::staticType);
    }
 
    template<typename T>
    typename std::enable_if<!std::is_abstract<T>::value>::type setConstructor() {
        setConstructor([](Object* parentScope) -> Object* {
            auto obj = new T();
            // Struct 及其派生类（例如 Class 元类自身）构造时会持有一个"初始强引用"
            // （见 Struct::Struct 中的 Object(initial_strong_ref)），用于保证静态存储期/
            // 栈上的元类对象不会被引用计数释放。这里创建的是堆对象，所有权交给调用者
            // （通常为 SharedPtr），因此需要先释放这次初始强引用，
            // 否则调用者释放后引用计数仍为 1，对象永远不会被释放。
            if (std::is_base_of<Struct, T>::value)
                obj->decRefNoDelete();
            obj->setParentScope(parentScope);
            return obj;
        });
    }
 
    template<typename T>
    typename std::enable_if<std::is_abstract<T>::value>::type setConstructor() {
        setConstructor(nullptr);
    }
 
    template<typename T>
    void setResolve()
    {
        typedef T* (*FResolveClsSpec)(StringView value);
        static_assert(std::is_same<decltype(&T::Resolve), FResolveClsSpec>::value, "T must have Resolve method with signature T* (StringView value)");
        setResolve(reinterpret_cast<FResolve>(&T::Resolve));
    }
public:
    void getAllProperties(std::vector<Property*>& out, bool overwriteSameName = false) const;
protected:
    Class* parent_{nullptr};                       
    FConstructor constructor_{nullptr};            
    FResolve resolve_{nullptr};                    
    SharedPtr<Object> defaultObject_{nullptr};     
};
 
 
AST_NAMESPACE_END