LibLinkedList.hpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#ifndef LIB_LINKED_LIST_HPP_
#define LIB_LINKED_LIST_HPP_

#include "LibMacros.hpp"


template<class T>
class LibLinkedList {
private:
    T* mFirst;
    T* mLast;
    int count;
public:
    LibLinkedList();
    ~LibLinkedList();

    void insert(T& item);
    void remove(T& item);
    T* getFirst();
    T* getLast();
};

template<class T>
class LIB_LINKED_LIST_ITERABLE {
    friend class LibLinkedList<T>;
private :
    T* mPrev;
    T* mNext;
protected:
    LIB_LINKED_LIST_ITERABLE();
    ~LIB_LINKED_LIST_ITERABLE();
public:
    T* getPrev();
    T* getNext();
};


template<class T>
LIB_LINKED_LIST_ITERABLE<T>::LIB_LINKED_LIST_ITERABLE() {
    mPrev = 0;
    mNext = 0;
}

template<class T>
LIB_LINKED_LIST_ITERABLE<T>::~LIB_LINKED_LIST_ITERABLE() {
    //Object must be removed from list before being destroyed
    LIB_ASSERT(mPrev == 0);//
    LIB_ASSERT(mNext == 0);//
}

template<class T>
T* LIB_LINKED_LIST_ITERABLE<T>::getPrev() {
    return mPrev;
}

template<class T>
T* LIB_LINKED_LIST_ITERABLE<T>::getNext() {
    return mNext;
}

template<class T>
LibLinkedList<T>::LibLinkedList() {
    mFirst = 0;
    mLast = 0;
    count = 0;
}

template<class T>
LibLinkedList<T>::~LibLinkedList() {
}

template<class T>
void LibLinkedList<T>::insert(T& item) {
    if (mLast) {
        mLast->mNext = &item;
        item.mPrev = mLast;
        mLast = &item;
    }
    else {
        item.mPrev = 0;
        mFirst = &item;
        mLast = &item;
    }
    item.mNext = 0;
    count++;
}

template<class T>
void LibLinkedList<T>::remove(T& item) {
    T* prev = item.mPrev;
    T* next = item.mNext;

    //Is this the first item in the list
    if (!prev) {
        //Is this the only item in the list
        if (!next) {
            mFirst = 0;
            mLast = 0;
        }
        else {
            mFirst = next;
            next->mPrev = 0;
        }
    }
    //Is this the last item in the list
    else if (!next) {

        mLast = prev;
        prev->mNext = 0;
    }
    //Otherwise we are in the middle of the list
    else {
        prev->mNext = next;
        next->mPrev = prev;
    }

    item.mPrev = 0;
    item.mNext = 0;

    count--;
}

template<class T>
T* LibLinkedList<T>::getFirst() {
    return mFirst;
}

template<class T>
T* LibLinkedList<T>::getLast() {
    return mLast;
}


#endif /* LIB_LINKED_LIST_HPP_ */