cList.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cList_H
#define _INC_cList_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "GrayCore.h"
#include "HResult.h"
#include "cUnitTestDecl.h"
#include "cDebugAssert.h"
#include "cHeapObject.h"
 
namespace Gray
{
        class cListBase;
 
        class GRAYCORE_LINK cListNodeBase : public cHeapObject
        {
                friend class cListBase; // so m_pNext and m_pPrev can be manipulated directly.
 
        private:
                cListBase* m_pParent;           
                cListNodeBase* m_pNext; 
                cListNodeBase* m_pPrev; 
 
        protected:
                virtual void put_Parent(cListBase* pParent)
                {
                        ASSERT(m_pParent == nullptr || pParent == nullptr || m_pParent == pParent);
                        m_pParent = pParent;            // link me back to my parent object.
                }
 
        protected:
                cListNodeBase() noexcept        // always just a base class.
                        : m_pParent(nullptr)    // not linked yet.
                        , m_pNext(nullptr)
                        , m_pPrev(nullptr)
                {
                }
 
        public:
                virtual ~cListNodeBase()
                {
                        ASSERT(!hasParent());
                }
 
                cListBase* get_Parent() const noexcept
                {
                        return m_pParent;
                }
                cListNodeBase* get_Next() const noexcept
                {
                        return m_pNext;
                }
                cListNodeBase* get_Prev() const noexcept
                {
                        return m_pPrev;
                }
 
                bool hasParent() const noexcept
                {
                        if (m_pParent != nullptr)
                        {
                                return true;
                        }
                        // If i have no parent i shouldnt have any siblings either.
                        DEBUG_CHECK(m_pNext == nullptr && m_pPrev == nullptr);           
                        return false;
                }
 
                void RemoveFromParent();
 
                virtual HRESULT DisposeThis()   // delete myself from the system.
                {
                        RemoveFromParent();     // called before destruct so virtual RemoveListNode() is called correctly.
                        return S_OK;
                }
        };
 
        //*************************************************
 
        class GRAYCORE_LINK cListBase   // generic list of objects based on cListNodeBase.
        {
 
                friend class cListNodeBase; // so it can call RemoveListNode() to remove self.
 
        protected:
                ITERATE_t m_iCount;             
        private:
                cListNodeBase* m_pHead; 
                cListNodeBase* m_pTail; 
 
        protected:
                virtual void RemoveListNode(cListNodeBase* pNode);      
 
        public:
                cListBase() noexcept
                        : m_iCount(0)
                        , m_pHead(nullptr)
                        , m_pTail(nullptr)
                {
                }
                virtual ~cListBase()
                {
                        ASSERT(isEmpty());
                }
 
                virtual void InsertListNode(cListNodeBase* pNodeNew, cListNodeBase* pNodePrev = nullptr);
                void InsertList(cListBase* pListSrc, cListNodeBase* pNodePrev = nullptr);
 
                void InsertBefore(cListNodeBase* pNodeNew, const cListNodeBase* pNodeNext)
                {
                        InsertListNode(pNodeNew, (pNodeNext != nullptr) ? (pNodeNext->get_Prev()) : get_Tail());
                }
                void InsertHead(cListNodeBase* pNodeNew)
                {
                        InsertListNode(pNodeNew, nullptr);
                }
                void InsertTail(cListNodeBase* pNodeNew)
                {
                        InsertListNode(pNodeNew, get_Tail());
                }
 
                void DisposeAll();
                void Empty();
 
                cListNodeBase* get_Head(void) const noexcept
                {
                        return m_pHead;
                }
                cListNodeBase* get_Tail(void) const noexcept
                {
                        return m_pTail;
                } 
                ITERATE_t get_Count() const noexcept
                {
                        return m_iCount;
                }
                bool isEmpty() const noexcept
                {
                        return get_Count() == 0;
                }
 
                cListNodeBase* GetAt(ITERATE_t index) const;
 
                bool IsMyChild(const cListNodeBase* pNode) const noexcept
                {
                        if (pNode == nullptr)
                                return false;
                        return pNode->get_Parent() == this;
                }
 
                UNITTEST_FRIEND(cList);
        };
 
        //*************************************************
 
        inline void cListNodeBase::RemoveFromParent()
        {
                if (m_pParent != nullptr)
                {
                        m_pParent->RemoveListNode(this); // only call this from here !
                        // ASSERT( m_pParent != pParentPrev );  // We are now unlinked. (or deleted)
                }
        }
 
        //*************************************************
        // template type casting for lists.
 
        template<class _TYPE_REC = cListNodeBase>
        class cListNodeT : public cListNodeBase
        {
                typedef cListNodeBase SUPER_t;
        public:
                _TYPE_REC* get_Next() const
                {
                        return static_cast<_TYPE_REC*>(SUPER_t::get_Next());
                }
                _TYPE_REC* get_Prev() const
                {
                        return static_cast<_TYPE_REC*>(SUPER_t::get_Prev());
                }
        };
 
        template<class _TYPE_REC /* = cListNodeBase */ >
        class cListT : public cListBase
        {
                typedef cListBase SUPER_t;
                typedef cListNodeT<_TYPE_REC> NODEBASE_t;
        public:
                _TYPE_REC* GetAt(ITERATE_t index) const
                {
                        return static_cast<_TYPE_REC*>(SUPER_t::GetAt(index));
                }
                _TYPE_REC* get_Head() const
                {
                        return static_cast<_TYPE_REC*>(SUPER_t::get_Head());
                }
                _TYPE_REC* get_Tail() const
                {
                        return static_cast<_TYPE_REC*>(SUPER_t::get_Tail());
                }
        };
}
#endif // _INC_cList_H