GxList.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxList : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxList, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxList)
 
    
    class GxNode;
    template <class T> class GxIterator;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxList(void) : _pTop(nullptr), _pBottom(nullptr), _count(0), _allocatorType(GxAllocatorList::ALLOCATOR_TYPE::GLOBAL){}
    GxList(GxAllocatorList::ALLOCATOR_TYPE allocatorType);
    ~GxList(void) override;
protected:
    virtual GxNode* allocGxNode(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_FORCE_INLINE GxIterator<void*> begin(void);
    GX_FORCE_INLINE GxIterator<void*> end(void);
    constexpr GxNode* getTop(void) const { return _pTop; }
    constexpr GxNode* getBottom(void) const { return _pBottom; }
    GxNode* getNode(u32 index) const;
    constexpr u32 getCount(void) const { return _count; }
    constexpr void setAllocatorType(GxAllocatorList::ALLOCATOR_TYPE allocatorType){ _allocatorType = allocatorType; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxNode* addTop(void* pObject);
    GxNode* addBottom(void* pObject);
    void insert(GxNode* pNode, void* pObject);
    virtual void erase(GxNode* pNode);
    virtual void eraseAll(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxList::GxNode* _pTop;      
    GxList::GxNode* _pBottom;   
    u32 _count;                 
    GxAllocatorList::ALLOCATOR_TYPE _allocatorType; 
 
};
 
//===========================================================================
//===========================================================================
class GxList::GxNode : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxList::GxNode, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxNode)
 
    friend class GxList;
    friend class GxListReference;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxNode(void) : _pObject(nullptr), _pParent(nullptr), _pPrevious(nullptr), _pNext(nullptr){}
    ~GxNode(void) override {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    constexpr GxList* getParent(void) const { return _pParent; }
    constexpr GxNode* getPrevious(void) const { return _pPrevious; }
    constexpr GxNode* getNext(void) const { return _pNext; }
    constexpr void* getObject(void) const { return _pObject; }
protected:
    virtual void setObject(void* pObject){ _pObject = pObject; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
protected:
    void* _pObject;     
    GxList* _pParent;   
private:
    GxNode* _pPrevious; 
    GxNode* _pNext;     
 
};
 
//===========================================================================
//===========================================================================
template<class T> class GxList::GxIterator
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public :
    GX_FORCE_INLINE GxIterator(GxList* pGxList) : _pList(pGxList){ _pCurrent = _pList->getTop(); }
    GX_FORCE_INLINE GxIterator(const GxList::GxIterator<T> &i) : _pList(i._pList), _pCurrent(i._pCurrent){}
    virtual ~GxIterator(void){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE const GxList::GxIterator<T>& operator = (GxList::GxIterator<T> &i){ _pList = i._pList; _pCurrent = i._pCurrent; return this; }
    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 GxNode* getCurrentNode(void) const { return _pCurrent; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
private:
    GxList* _pList;         
    GxNode* _pCurrent;      
 
};
 
#include "GxList.inl"
 
GX_CORE_NAMESPACE_END()