GxBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
#if GX_DEVELOP
class GxGuiBase;
#endif //GX_DEVELOP
class GxArrayClassBase;
 
//===========================================================================
//===========================================================================
struct GxStructBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTIの取得
    static GxRtti& __getStaticRtti(void){ return GxRtti::getRttiRoot(); }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);
#endif //GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxClassBaseRoot
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    constexpr GxClassBaseRoot(void){}
    constexpr GxClassBaseRoot(const GxClassBaseRoot&){}
    virtual ~GxClassBaseRoot(void){}
    constexpr GxClassBaseRoot& operator = (const GxClassBaseRoot& /*classBaseRoot*/){ return *this; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GX_FORCE_INLINE static GxRtti& __getStaticRtti(void){ return GxRtti::getRttiRoot(); }
    virtual GxRtti& getRtti(void) const = 0;
    GX_FORCE_INLINE virtual const GxTypedObject* getDefaultObject(void) { return getRtti().getDefaultObject(); }
    GX_FORCE_INLINE b32 isDefaultObject(void) { return getDefaultObject() == this; }
 
};
 
//===========================================================================
//===========================================================================
class GxClassBase : public GxClassBaseRoot
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxClassBase, GxClassBaseRoot)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    constexpr GxClassBase(void){}
    constexpr GxClassBase(const GxClassBase& base) : GxClassBaseRoot(base){}
    ~GxClassBase(void) override {}
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index){ return  GxStructBase::createGui(property, pOwner, rtti, index); }
#endif //GX_DEVELOP
 
};
 
class GxCriticalSection;
//===========================================================================
//===========================================================================
class GxClassBaseReference : public GxClassBaseRoot
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxClassBaseReference, GxClassBaseRoot)
    static constexpr s32 DELAY_RELEASE_COUNT_INFINITY = -1;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxClassBaseReference(void);
    GxClassBaseReference(const GxClassBaseReference& base);
    ~GxClassBaseReference(void) override;
    virtual void cleanup(void);
    static void initializeDelayRelease(void);
    static void terminateDelayRelease(void);
 
    constexpr GxClassBaseReference& operator = (const GxClassBaseReference& base);
 
private:
#if GX_DEBUG_NEW
    constexpr void* operator new[](size_t size, GX_CSTR filename = __FILE__, u32 line = __LINE__);
#else   // GX_DEBUG_NEW
    constexpr void* operator new[](size_t size);
#endif  // GX_DEBUG_NEW
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    virtual s32 addReference(void);
    virtual s32 release(void);
    static void updateDelayRelease(void);
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index){ return  GxStructBase::createGui(property, pOwner, rtti, index); }
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    virtual s32 getReferenceCount(void) const { return _referenceCount; }
    static b32 isDelayReleaseEnable(void){ return _delayReleaseFlag; }
    static u32 getDelayReleaseListCount(void);
    constexpr void setDelayReleaseCount(s32 count) { _delayReleaseCount = count; }
    void setDelayReleaseCountInfinity(b32 on){ _delayReleaseCount = (on ? DELAY_RELEASE_COUNT_INFINITY : 0); }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    s32 _referenceCount;                
    s32 _delayReleaseCount;             
private:
    static GxArrayClassBase* _pDelayReleaseList;    
    static b32 _delayReleaseFlag;       
    static GxCriticalSection** _ppDelayReleaseCriticalSection;  
#if GX_DEVELOP
    b32 _cleanupFlag;                   
#endif //GX_DEVELOP
 
};
 
//---------------------------------------------------------------------------
// オブジェクトメンバ関数へのポインタ
//---------------------------------------------------------------------------
typedef void (GxClassBaseRoot::* GX_OBJECT_FUNCTION)(void);
typedef void (GxClassBaseRoot::* GX_OBJECT_FUNCTION_PARAM)(u32);
typedef void (GxClassBaseRoot::* GX_OBJECT_FUNCTION_POINTER)(void*);
 
//---------------------------------------------------------------------------
// 継承クラス用禁止宣言マクロ (継承クラスはクラス宣言に組み込むこと)
//---------------------------------------------------------------------------
#define GX_PROHIBIT_NEW(__CLASS__)                                      \
    protected:                                                          \
        /* デストラクタ (GX_NEW, GX_RELEASE以外での生成・破棄禁止) */    \
        ~__CLASS__(void) override {}                                    \
 
#define GX_PROHIBIT_COPY(__CLASS__)                                 \
    /* コピーコンストラクタ (コピー禁止) */                            \
    __CLASS__(const __CLASS__&) = delete;                           \
    /* 代入演算子 (コピー禁止) */                                 \
    GX_FORCE_INLINE const __CLASS__& operator=(const __CLASS__&) = delete;  \
 
#define GX_PROHIBIT_CLASS_BASE(__CLASS__)                       \
    GX_PROHIBIT_COPY(__CLASS__)                                 \
 
#define GX_PROHIBIT_CLASS_BASE_REFERENCE(__CLASS__)             \
    GX_PROHIBIT_NEW(__CLASS__)                                  \
    GX_PROHIBIT_COPY(__CLASS__)                                 \
    public:
 
#define GX_PROHIBIT_CLASS_BASE_REFERENCE_ALLOW_COPY(__CLASS__)  \
    GX_PROHIBIT_NEW(__CLASS__)                                  \
    public:
 
//---------------------------------------------------------------------------
// 
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template<class T> T gx_cast(GxClassBaseRoot* pObject)
{
    if(!pObject)
    {
        return nullptr;
    }
    else if(!pObject->getRtti().isDerived(((T)0)->GX_RTTI))
    {
        return nullptr;
    }
    return static_cast<T>(pObject);
}
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template<class T> T gx_cast(const GxClassBaseRoot* pObject)
{
    if(!pObject)
    {
        return nullptr;
    }
    else if(!pObject->getRtti().isDerived(((T)0)->GX_RTTI))
    {
        return nullptr;
    }
    return static_cast<T>(pObject);
}
 
//---------------------------------------------------------------------------
// 代入演算子
//---------------------------------------------------------------------------
constexpr GxClassBaseReference& GxClassBaseReference::operator = (const GxClassBaseReference& base)
{
    if(this == &base)
    {
        return *this;
    }
    Super::operator = (base);
    _referenceCount = base._referenceCount;
    _delayReleaseCount = base._delayReleaseCount;
    return *this;
}
 
GX_CORE_NAMESPACE_END()
 
 
#define GX_SAFE_RELEASE(__POINTER__) if(__POINTER__){ GxClassBaseReference* __pOld__ = __POINTER__; __POINTER__ = nullptr; __pOld__->release(); }
#define GX_SET_CLASS_BASE_REFERENCE(__DST__, __SRC__) { \
    GxClassBaseReference* __pOldBase__ = (__DST__); \
    __DST__ = (__SRC__); \
    if(__DST__) \
    { \
        (__DST__)->addReference(); \
    } \
    GX_SAFE_RELEASE(__pOldBase__); \
}