tlist.h

// This software is distributed as part of the Improla library. 
// Improla is a GUI framework for image processing.
// 
// Copyright (c) 2004, B. R. Siva Chandra, India
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// In case you would like to contact the author, use the following e-mail
// address: sivachandra_br@yahoo.com

#ifndef __T_LIST_H__
#define __T_LIST_H__

#ifndef NULL
#define NULL 0
#endif // NULL

namespace tutk
{

template <class T>
class NODE
{
public:
    NODE(void);
    
    ~NODE();
    
    NODE *nextNodePtr;
    NODE *previousNodePtr;
    T data;
};

template <class T> 
NODE<T>::NODE(void) 
{
    nextNodePtr = previousNodePtr = NULL;
    data = T();
}

template <class T> 
NODE<T>::~NODE() { ; }

template <class T>
class List
{
public:
    List(void);
    
    List(const List &l);
    
    ~List();
    
    //bool insert(T node, int location); // TO DO...
    
    void append(T node);
    
    void push(T node);
    
    void pop(void);
    
    //bool remove(int location);         // TO DO...
    
    void destroy(void);
    
    void refresh(void); // This resets the currentNodePtr to the firstNode.
    
    T getLastNode(bool& validity);     
    
    T getNode(bool& validity);
    
    T* getPointerToNodeItem(void);
    
    int getSize(void);
    
    T* getPointerToLastItem(void);
    
    void operator=(const List &l);
        
private:
    int *size;
    int *refCount;
    NODE<T> *firstNodePtr, *lastNodePtr;
    NODE<T> *currentNodePtr;     
};

// List implementation...

// Constructor...
template <class T>
List<T>::List(void)
{
    firstNodePtr = lastNodePtr = currentNodePtr = NULL;
    
    size = new int; refCount = new int;
    *size = 0; *refCount = 1;
}

template <class T>
List<T>::List(const List &l)
        : firstNodePtr(l.firstNodePtr), currentNodePtr(l.currentNodePtr), 
          lastNodePtr(l.lastNodePtr), size(l.size), refCount(l.refCount)
{
    (*refCount)++;
}        

template <class T>
List<T>::~List()
{
    if (*refCount <= 1)
    {
        destroy();
        delete size; delete refCount;
    }    
    else
        (*refCount)--;
}

template <class T>
void List<T>::append(T node)
{
    NODE<T> *newNodePtr = new NODE<T>();
    
    if (*size == 0)
        firstNodePtr = currentNodePtr = newNodePtr;
    else
    {
        newNodePtr->previousNodePtr = lastNodePtr;
        lastNodePtr->nextNodePtr = newNodePtr;
    }
    
    lastNodePtr = newNodePtr;
    lastNodePtr->data = T(node);
    (*size)++;
    
    return;   
}

template <class T>
void List<T>::refresh(void)
{
    currentNodePtr = firstNodePtr;
    return;
}

template <class T>
T List<T>::getNode(bool& validity)
{
    if (*size == 0 || currentNodePtr == NULL)
    {
        T dummy;
        validity = false;
        return dummy;
    }
    else
    {
        T nodeData = T(currentNodePtr->data);
        currentNodePtr = currentNodePtr->nextNodePtr;
        validity = true;
        return nodeData;
    }
}

template <class T>
T* List<T>::getPointerToNodeItem(void)
{
    if (*size == 0 || currentNodePtr == NULL)
        return NULL;
    else
    {
        T *dataPtr = &(currentNodePtr->data);
        return dataPtr;
    }
}    

template <class T>
void List<T>::pop(void)
{
    if (*size == 0)
        return;
    else if (*size == 1)
    {
        delete firstNodePtr;
        lastNodePtr = firstNodePtr = currentNodePtr = NULL;
        (*size)--;
        
        return;
    }
            
    lastNodePtr = lastNodePtr->previousNodePtr;
    delete lastNodePtr->nextNodePtr;
    lastNodePtr->nextNodePtr = NULL;
    (*size)--;
    
    return;
}

template <class T>
void List<T>::push(T node)
{
    append(node);
    return;
}    

template <class T>
void List<T>::destroy(void)
{
    int s = *size;
    
    for (int i = 1; i <= s; i++)
        pop();
        
    return;
}

template <class T>
T List<T>::getLastNode(bool& validity)
{
    if (*size == 0)
    {
        T dummy;
        validity = false;
        return dummy;
    }
    else
    {
        T lastNodeData = T(lastNodePtr->data);
        validity = true;
        return lastNodeData;
    }
}

template <class T>
T* List<T>::getPointerToLastItem(void)
{
    if (lastNodePtr == NULL)
        return NULL;
    else
        return &(lastNodePtr->data);
}
    
template <class T>
int List<T>::getSize(void)
{
    return *size;
}

template <class T>
void List<T>::operator=(const List &l)
{
    if (*refCount <= 1)
    {
        destroy();
        delete size; delete refCount;
        
        firstNodePtr = l.firstNodePtr;
        currentNodePtr = l.currentNodePtr;
        lastNodePtr = l.lastNodePtr;
        size = l.size;
        refCount = l.refCount;
        (*refCount)++;
    }
    else
    {
        (*refCount)--;
        
        firstNodePtr = l.firstNodePtr;
        currentNodePtr = l.currentNodePtr;
        lastNodePtr = l.lastNodePtr;
        size = l.size;
        refCount = l.refCount;
        (*refCount)++;
    }
    
    return;        
}    

} // End of namespace...

#endif  // __T_LIST_H__

---