F:/My Projects/LSEngine/Modules/LSTL/Src/LinkedList/LSTLSingleLinkedList.h

#ifndef __LSTL_SINGLELINKEDLIST_H__
#define __LSTL_SINGLELINKEDLIST_H__

#include "../LSTLib.h"
#include "LSTLLinkedListBase.h"

namespace lstl {

        template <typename _tType>
        class CSingleLinkedList : protected CLinkedListBase {
        public :
                // == Various constructors.
                LSE_CALL                                                                CSingleLinkedList() :
                        m_lpllnHead( NULL ),
                        m_paOurAllocator( &Parent::m_aAllocator ) {
                }
                LSE_CALL                                                                ~CSingleLinkedList() {
                        Reset();
                }


                // == Types.
                typedef struct LSTL_LINKED_LIST_NODE {
                        _tType                                                          tLinkedListObject;

                        LSTL_LINKED_LIST_NODE *                         pllnLinkedListNext;
                } * LPLSTL_LINKED_LIST_NODE, * const LPCLSTL_LINKED_LIST_NODE;


                // == Functions.
                LSVOID LSE_CALL                                                 SetAllocator( CAllocator * _paAllocator ) {
                        Reset();
                        m_paOurAllocator = _paAllocator;
                        if ( !m_paOurAllocator ) {
                                m_paOurAllocator = &Parent::m_aAllocator;
                        }
                }

                CAllocator * LSE_CALL                                   GetAllocator() {
                        return m_paOurAllocator;
                }

                LSVOID LSE_CALL                                                 Reset() {
                        LPLSTL_LINKED_LIST_NODE lpllnNext = NULL;
                        for ( LPLSTL_LINKED_LIST_NODE lpllnThis = m_lpllnHead;
                                lpllnThis; lpllnThis = lpllnNext ) {
                                lpllnNext = lpllnThis->pllnLinkedListNext;
                                Destroy( (*lpllnThis) );
                                m_paOurAllocator->Free( lpllnThis );
                        }

                        m_lpllnHead = NULL;
                }

                LPLSTL_LINKED_LIST_NODE LSE_CALL                InsertAfter( const _tType &_tNew, LPLSTL_LINKED_LIST_NODE _lpllnNode ) {
                        LPLSTL_LINKED_LIST_NODE lpllnNew = NewNode();
                        if ( !lpllnNew ) { return NULL; }
                        Construct( (*lpllnNew) );
                        lpllnNew->tLinkedListObject = _tNew;

                        if ( !_lpllnNode ) {
                                // Insert at the head.
                                lpllnNew->pllnLinkedListNext = m_lpllnHead;
                                m_lpllnHead = lpllnNew;
                        }
                        else {
                                // Otherwise it goes after some item or another.
                                lpllnNew->pllnLinkedListNext = _lpllnNode->pllnLinkedListNext;
                                _lpllnNode->pllnLinkedListNext = lpllnNew;
                        }

                        return lpllnNew;
                }

                LSVOID LSE_CALL                                                 RemoveItem( LPLSTL_LINKED_LIST_NODE _lpllnNode ) {
                        if ( !_lpllnNode ) { return; }
                        // Unlink the object.
                        if ( m_lpllnHead == _lpllnNode ) {
                                // At the head.
                                m_lpllnHead = _lpllnNode->pllnLinkedListNext;
                        }
                        else {
                                // Find the node before it.
                                for ( LPLSTL_LINKED_LIST_NODE pllnThis = m_lpllnHead; pllnThis; pllnThis = pllnThis->pllnLinkedListNext ) {
                                        if ( pllnThis->pllnLinkedListNext == _lpllnNode ) {
                                                pllnThis->pllnLinkedListNext = _lpllnNode->pllnLinkedListNext;
                                                break;
                                        }
                                }
                        }

                        Destroy( (*_lpllnNode) );
                        m_paOurAllocator->Free( _lpllnNode );
                }

                LPLSTL_LINKED_LIST_NODE LSE_CALL                Head() {
                        return m_lpllnHead;
                }

                const LPLSTL_LINKED_LIST_NODE LSE_CALL  Head() const {
                        return m_lpllnHead;
                }

                LPLSTL_LINKED_LIST_NODE LSE_CALL                PushFront( const _tType &_tNew ) {
                        return InsertAfter( _tNew, NULL );
                }

                LSUINT32 LSE_CALL                                               Length() {
                        LSUINT32 ui32Len = 0UL;
                        for ( LPLSTL_LINKED_LIST_NODE lpllnThis = m_lpllnHead;
                                lpllnThis; lpllnThis = lpllnThis->pllnLinkedListNext ) {
                                ++ui32Len;
                        }
                        return ui32Len;
                }

                LPLSTL_LINKED_LIST_NODE LSE_CALL                Find( const _tType &_tValue ) {
                        for ( LPLSTL_LINKED_LIST_NODE lpllnThis = m_lpllnHead;
                                lpllnThis; lpllnThis = lpllnThis->pllnLinkedListNext ) {
                                if ( lpllnThis->tLinkedListObject == _tValue ) {
                                        return lpllnThis;
                                }
                        }
                        return NULL;
                }


        protected :
                // == Members.
                LPLSTL_LINKED_LIST_NODE                                 m_lpllnHead;

                CAllocator *                                                    m_paOurAllocator;

                
                // == Functions.
                LSVOID LSE_CALL                                                 Construct( LSTL_LINKED_LIST_NODE &_llnNode ) {
                        _llnNode.pllnLinkedListNext = NULL;
                        new( &_llnNode.tLinkedListObject ) _tType;
                }
                LSVOID LSE_CALL                                                 Destroy( const LSTL_LINKED_LIST_NODE &_llnNode ) {
                        // This gives warning C4100 when this class is created with types that have no destructor,
                        //      claiming _llnNode is unreferenced.
                        // Erase this warning with some do-nothing code.
#ifdef LSE_VISUALSTUDIO
                        static_cast<LSTL_LINKED_LIST_NODE>(_llnNode);
#endif  // #ifdef LSE_VISUALSTUDIO
                        _llnNode.tLinkedListObject.~_tType();
                }

                LPLSTL_LINKED_LIST_NODE LSE_CALL                NewNode() {
                        return static_cast<LPLSTL_LINKED_LIST_NODE>(m_paOurAllocator->Alloc( sizeof( LSTL_LINKED_LIST_NODE ) ));
                }

        private :
                typedef CLinkedListBase                                 Parent;
        };

}       // namespace lstl

#endif  // __LSTL_SINGLELINKEDLIST_H__