Days go by, and still I think about you

#ifndef DLLIST_H_
#define DLLIST_H_

// Authored by Michael Kofman
// July 17, 2007

template <typename Type> class DLLIter;

template <typename Type>
class DLList
{
private:
friend class DLLIter<Type>;
struct Node
{
Type m_data;
Node * pNext;
Node * pPrev;
};
Node * pHead;
Node * pTail;

public:
// DLList : constructor.
DLList ()
{
pHead = pTail = 0;
}

// ~DLList : destructor.
virtual ~DLList ()
{
clear();
}

// addHead : append a new item to the front of the list.
void addHead (const Type &v)
{
Node * temp = new Node;
temp->m_data = v;
temp->pPrev = 0;

if(!pTail && !pHead)
{
temp->pNext = 0;
pHead = pTail = temp;
}else
{
temp->pNext = pHead;
pHead->pPrev = temp;
pHead = temp;
}
}

// addTail : append a new item to the back of the list.
void addTail (const Type &v)
{
Node * temp = new Node;
temp->m_data = v;

temp->pNext = 0;

if(!pTail && !pHead)
{
temp->pPrev = 0;
pHead = pTail = temp;
}else
{
temp->pPrev = pTail;
pTail->pNext = temp;
pTail = temp;
}

}

// clear : clear out the list
void clear ()
{
Node * temp;
while(pHead)
{
temp = pHead;
pHead = pHead->pNext;
delete temp;
}
pTail = 0;
}

// insert : place a new item directly before the index
// passed in. Do nothing on a bad iterator.
// Note : iterator will point at the newly inserted
// item after the function call.
void insert (DLLIter<Type> &index, const Type &v)
{
if(index.curPos)
{
Node * temp = new Node;
temp->m_data = v;

temp->pPrev = index.prevPos;
temp->pNext = index.curPos;
index.curPos->pPrev = temp;
index.prevPos->pNext = temp;

index.curPos = temp;

if(!temp->pNext)
pTail = temp;

if(!temp->pPrev)
pHead = temp;
}
}

// remove : remove (and delete) the item at the index
// passed in. Do nothing on a bad iterator.
// Note : iterator will point at the item after the one
// removed after the function call, or NULL (bad) if
// the tail is the one removed.
void remove (DLLIter<Type> &index)
{
if(index.curPos)
{
Node * temp = index.curPos;

if(!index.curPos->pNext) // Removing Tail
{
if(index.curPos->pPrev)
{
index.list->pTail = index.prevPos;
index.prevPos->pNext = 0;
}else // Removing last item in List
{
index.list->pHead = index.list->pTail = 0;
}

}else if(!index.curPos->pPrev) // Removing Head
// Did not include extra empty list check due to presedence
{
index.curPos = temp->pNext;
index.curPos->pPrev = 0;
index.list->pHead = index.curPos;
}else
{
index.curPos->pNext->pPrev = index.prevPos;
index.curPos->pPrev->pNext = index.curPos->pNext;
}

delete temp;
}
}
};

template <typename Type>
class DLLIter
{
private:
friend class DLList<Type>;
DLList<Type> * list;
typename DLList<Type>::Node *curPos;
typename DLList<Type>::Node *prevPos;

public:
// DLLIter : constructor.
DLLIter (DLList<Type> &listToIterate)
{
list = &listToIterate;
curPos = prevPos = 0;
}

// ~DLLIter : destructor.
virtual ~DLLIter ()
{
delete curPos;
delete prevPos;
}

// beginHead : start the location at the head of the list
void beginHead ()
{
curPos = list->pHead;
prevPos = 0;
}

// beginTail : start the location at the tail of the list
void beginTail ()
{
if(list->pTail)
{
curPos = list->pTail;
prevPos = curPos->pPrev;
}
}

// end : only return true when iterator is NULL
bool end()
{
if(curPos)
return false;
return true;
}

// operator++ : prefix ++ operator for incrementing
// iterator to the next node in the list.
DLLIter<Type> &operator++ ()
{
prevPos = curPos;
curPos = curPos->pNext;
return *this;
}

// operator-- : prefix -- operator for decrementing
// iterator to the previous node in the list.
DLLIter<Type> &operator-- ()
{
curPos = prevPos;
if(prevPos)
prevPos = prevPos->pPrev;
else
prevPos = 0;
return *this;
}

// current : extract the element at the current location.
Type &current ()
{
return curPos->m_data;
}
};
#endif