GxListClassBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxListClassBase : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxListClassBase, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxListClassBase)
 
    
    class GxNodeClassBase;
    template <class T> class GxIterator;
    enum class SORT
    {
        UP,                 
        DOWN,               
#if GX_DEVELOP
        CLASSNAME_UP,       
        CLASSNAME_DOWN,     
        RTTINAME_UP,        
        RTTINAME_DOWN       
#endif //GX_DEVELOP
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxListClassBase(void): _pTop(nullptr), _pBottom(nullptr), _count(0), _allocatorType(GxAllocatorList::ALLOCATOR_TYPE::GLOBAL){}
    GxListClassBase(GxAllocatorList::ALLOCATOR_TYPE allocatorType);
    ~GxListClassBase(void) override;
protected:
    virtual GxNodeClassBase* allocNode(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_FORCE_INLINE GxIterator<GxClassBaseRoot*> begin(void);
    GX_FORCE_INLINE GxIterator<GxClassBaseRoot*> end(void);
    constexpr GxNodeClassBase* getTop(void) const { return _pTop; }
    constexpr GxNodeClassBase* getBottom(void) const { return _pBottom; }
    GxNodeClassBase* getNode(u32 index) const;
    constexpr u32 getCount(void) const { return _count; }
    constexpr void setAllocatorType(GxAllocatorList::ALLOCATOR_TYPE allocatorType){ _allocatorType = allocatorType; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxNodeClassBase* addTop(GxClassBaseRoot* pObject);
    GxNodeClassBase* addBottom(GxClassBaseRoot* pObject);
    void insert(GxNodeClassBase* pNodeClassBase, GxClassBaseRoot* pObject);
    void erase(GxNodeClassBase* pNodeClassBase);
    void eraseAll(void);
    void sortQuick(GxProperty* pProperty, const SORT sort);
 
private:
    template<class T> void sortQuickSub(GxProperty* pProperty, GxNodeClassBase* pTop, GxNodeClassBase* pBottom, SORT sort);
    template<class T> b32 getCompareResult(T& value0, T& value1, SORT sort);
    template<class T> void getValue(GxProperty* pProperty, GxClassBaseRoot* pObject, T& value, SORT sort);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxListClassBase::GxNodeClassBase* _pTop;        
    GxListClassBase::GxNodeClassBase* _pBottom;     
    u32 _count;                                     
    GxAllocatorList::ALLOCATOR_TYPE _allocatorType; 
 
};
 
template<> b32 GxListClassBase::getCompareResult<GxString>(GxString& value0, GxString& value1, SORT sort);
template<> void GxListClassBase::getValue<GxString>(GxProperty* pProperty, GxClassBaseRoot* pObject, GxString& value, SORT sort);
 
//===========================================================================
//===========================================================================
class GxListClassBase::GxNodeClassBase : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxListClassBase::GxNodeClassBase, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxNodeClassBase)
 
    friend class GxListClassBase;
    friend class GxListClassBaseReference;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxNodeClassBase(void) : _pObject(nullptr), _pParent(nullptr), _pPrevious(nullptr), _pNext(nullptr){}
    ~GxNodeClassBase(void) override {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    constexpr GxListClassBase* getParent(void) const { return _pParent; }
    constexpr GxNodeClassBase* getPrevious(void) const { return _pPrevious; }
    constexpr GxNodeClassBase* getNext(void) const { return _pNext; }
    constexpr GxClassBaseRoot* getObject(void) const { return _pObject; }
protected:
    virtual void setObject(GxClassBaseRoot* pObject){ _pObject = pObject; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
protected:
    GxClassBaseRoot* _pObject;      
    GxListClassBase* _pParent;      
private:
    GxNodeClassBase* _pPrevious;    
    GxNodeClassBase* _pNext;        
 
};
 
//===========================================================================
//===========================================================================
template<class T> class GxListClassBase::GxIterator
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public :
    GX_FORCE_INLINE GxIterator(GxListClassBase* pListClassBase) : _pListClassBase(pListClassBase){ _pCurrent = _pListClassBase->getTop(); }
    GX_FORCE_INLINE GxIterator(const GxListClassBase::GxIterator<T> &i) : _pListClassBase(i._pListClassBase), _pCurrent(i._pCurrent){}
    virtual ~GxIterator(void){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE const GxListClassBase::GxIterator<T>& operator = (GxListClassBase::GxIterator<T> &i){ _pListClassBase = i._pListClassBase; _pCurrent = i._pCurrent; return this; }
    GX_FORCE_INLINE T operator*(void) const { return getCurrent(); }
    GX_FORCE_INLINE GxIterator<T>& operator++(void) { getNext(); return *this; }
    GX_FORCE_INLINE b32 operator!=(const GxIterator& iterator) const { return getCurrent() != iterator.getCurrent(); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE const T operator[](u32 i) const;
    GX_FORCE_INLINE T operator[](u32 i);
    GX_FORCE_INLINE T getTop(void);
    GX_FORCE_INLINE T getBottom(void);
    GX_FORCE_INLINE T getPrevious(void);
    GX_FORCE_INLINE T getCurrent(void) const;
    GX_FORCE_INLINE T getNext(void);
    GX_FORCE_INLINE T getFromIndex(u32 index) const { return this[index]; }
    constexpr GxNodeClassBase* getCurrentNode(void) const { return _pCurrent; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxListClassBase* _pListClassBase;   
    GxNodeClassBase* _pCurrent;         
 
};
 
//===========================================================================
//===========================================================================
class GxListClassBaseReference : public GxListClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxListClassBaseReference, GxListClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxListClassBaseReference)
 
    
    class GxNodeClassBaseReference;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxListClassBaseReference(GxAllocatorList::ALLOCATOR_TYPE allocatorType) : GxListClassBase(allocatorType){}
    ~GxListClassBaseReference(void) override {}
protected:
    GxNodeClassBase* allocNode(void) override;
 
private:
    GxListClassBaseReference(void) : GxListClassBase(GxAllocatorList::ALLOCATOR_TYPE::GLOBAL){}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_FORCE_INLINE GxNodeClassBaseReference* getTop(void) const;
    GX_FORCE_INLINE GxNodeClassBaseReference* getBottom(void) const;
    GX_FORCE_INLINE GxNodeClassBaseReference* getNode(u32 index) const;
 
};
 
//===========================================================================
//===========================================================================
class GxListClassBaseReference::GxNodeClassBaseReference : public GxListClassBase::GxNodeClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxListClassBaseReference::GxNodeClassBaseReference, GxListClassBase::GxNodeClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxNodeClassBaseReference)
 
    friend class GxListClassBaseReference;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxNodeClassBaseReference(void){}
    ~GxNodeClassBaseReference(void) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GX_FORCE_INLINE GxListClassBaseReference* getParent(void) const;
    GX_FORCE_INLINE GxNodeClassBaseReference* getPrevious(void) const;
    GX_FORCE_INLINE GxNodeClassBaseReference* getNext(void) const;
    GX_FORCE_INLINE GxClassBaseReference* getObject(void) const;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    void setObject(GxClassBaseRoot* pObject) override;
private:
    void releaseObject(void);
 
};
 
#include "GxListClassBase.inl"
 
GX_CORE_NAMESPACE_END()