D:/Zythum/DinoKod/Common/List.h

#ifndef __LIST_H__
#define __LIST_H__

#include "Common/CommonDll.h"
//#include <list>
#include "Common/Assert.h"
#include "Common/Types.h"

#pragma warning( disable : 4251 )

/*using namespace std;

//---------------------------------------------------------------------------------------------------------------------
template <class TYPE>
class KList
{
protected:
        list<TYPE>              m_List;

public:
                                        KList()                                 {}
//                                      ~KList()                                { KASSERT( m_List.empty() );                                            }

        void                    Clear()                                 { m_List.clear();                                                               }
        void                    Add( TYPE pData )               { m_List.push_back( pData );                                    }
        void                    Remove( TYPE pData )    { m_List.remove( pData );                                               }
        u32                             GetSize()                               { return (u32)m_List.size();                                    }

        TYPE                    GetFirst()                              { return GetSize() ? *m_List.begin() : NULL;    }
        TYPE                    GetNext( TYPE pData )
        {
                list<TYPE>::iterator    i;

                for(i = m_List.begin();i != m_List.end();++i)
                {
                        if( *i == pData )
                        {
                                i++;
                                if( i == m_List.end() )
                                        return NULL;

                                return *i;
                        }
                }
                return NULL;
        }
        TYPE                    GetLast()                               { return GetSize() ? *m_List.end() : NULL;              }
};
*/
//---------------------------------------------------------------------------------------------------------------------
class /*COMMON_API*/ KListElement
{
public:
        void*                   m_pElement;
        KListElement*   m_pPrev;
        KListElement*   m_pNext;
};


template <class TYPE>
class /*COMMON_API*/ KList
{
protected:
        KListElement*   m_pCurrElement;
        KListElement*   m_pHead;
        KListElement*   m_pTail;
        u32                             m_Size;

public:
        KList()
        {
                m_pCurrElement  = NULL;
                m_pHead                 = NULL;
                m_pTail                 = NULL;
                m_Size                  = 0;
        }

        ~KList()
        {
                KASSERT( m_Size == 0 );
        }

        // Efface tout les élements
        void                    Clear()
        {
                KListElement*   pElement = m_pHead;
                KListElement*   pNext;

                while( pElement )
                {
                        pNext = pElement->m_pNext;
                        SafeDeletep( pElement );
                        pElement = pNext;
                }

                m_pHead                 = NULL;
                m_pTail                 = NULL;
                m_pCurrElement  = NULL;
                m_Size                  = 0;
        }

        // Ajoute un nouvel élement en queue de liste
        void                    Add( TYPE pData )
        {
                KListElement*   pElement = new KListElement();
                pElement->m_pElement    = (void*)pData;
                pElement->m_pPrev               = m_pTail;
                pElement->m_pNext               = NULL;
                if( m_pTail )
                        m_pTail->m_pNext        = pElement;

                m_pTail                                 = pElement;

                if( !m_pHead )
                        m_pHead = pElement;

                m_Size ++;
        }

        // Retire l'élément de la liste
        void                    Remove( TYPE pData )
        {
                KListElement*   pElement = m_pHead;

                while( pElement )
                {
                        if( pElement->m_pElement == (void*)pData )
                        {
                                if( pElement->m_pPrev )
                                        pElement->m_pPrev->m_pNext = pElement->m_pNext;
                                else
                                        m_pHead = pElement->m_pNext;

                                if( pElement->m_pNext )
                                        pElement->m_pNext->m_pPrev = pElement->m_pPrev;
                                else
                                        m_pTail = pElement->m_pPrev;

                                SafeDeletep( pElement );

                                m_Size --;

                                return;
                        }
                        pElement = pElement->m_pNext;
                }
        }

        u32                             GetSize()                               { return m_Size;        }

        TYPE                    GetFirst()
        {
                // Garde le pointeur de début en cache
                m_pCurrElement = m_pHead;
                // Retourne le premier élement
                return (m_pHead ? (TYPE)m_pHead->m_pElement : (TYPE)NULL);
        }

        TYPE                    GetLast()
        {
                // Garde le pointeur de fin en cache
                m_pCurrElement = m_pTail;
                // Retourne le dernier élément
                return (m_pTail ? (TYPE)m_pTail->m_pElement : (TYPE)NULL);
        }

        TYPE                    GetNext( TYPE pData )
        {
                KListElement*   pElement = m_pHead;

                // Vérifie si le pointeur en cache est le bon
                if( m_pCurrElement && m_pCurrElement->m_pElement && (m_pCurrElement->m_pElement == (void*)pData ) )
                {
                        m_pCurrElement = m_pCurrElement->m_pNext;
                        return (m_pCurrElement ? (TYPE)m_pCurrElement->m_pElement : (TYPE)NULL);
                }

                // Recherche l'élement
                while( pElement )
                {
                        if( pElement->m_pElement == (void*)pData )
                        {
                                m_pCurrElement = pElement;
                                return (pElement->m_pNext ? (TYPE)pElement->m_pNext->m_pElement : (TYPE)NULL);
                        }

                        pElement = pElement->m_pNext;
                }
                return (TYPE)NULL;
        }

        TYPE                    GetPosition( u32 Position )
        {
                TYPE    Element = GetFirst();

                while( Position -- )
                {
                        Element = GetNext( Element );
                }

                return Element;
        }
};

#endif //       __LIST_H__

---