t_list.h

Go to the documentation of this file.

//                                                         //
// Copyright (c) 2003-2014 by The University of Queensland //
// Centre for Geoscience Computing                         //
// http://earth.uq.edu.au/centre-geoscience-computing      //
//                                                         //
// Primary Business: Brisbane, Queensland, Australia       //
// Licensed under the Open Software License version 3.0    //
// http://www.opensource.org/licenses/osl-3.0.php          //
//                                                         //

#ifndef _T_LIST_H_
#define _T_LIST_H_
#include <string.h>
#ifndef NULL
#define NULL 0
#endif

#ifdef _LINUX
#include <stddef.h>
#endif

#ifdef _DEBUG
#include "console.h"
#endif

template<class T>
class Node
{
public:
  Node<T> *Next, *Prev ;
  T *Val ;
} ;

template <class T>
class List
   {
   protected:
     Node<T> *Start ;   
     Node<T> *End;      
     Node<T> *Current ; 
   public:
      inline List() ;
      inline List(const List &L) ;
      virtual ~List() ;

      inline void Swap() ;
      inline void InsertAtStart(T *V) ; 
      inline void Append(T *V) ;        
      inline void InsertAfter(T *V) ; 
      inline void InsertBefore(T *V) ;  
      inline T* Get() ;
      inline void Put(T *V) ;

      inline void Clear() ;
      inline void Destroy() ;

      inline List& operator << (T *V) ;
      inline List& operator >> (T *V) ;

      inline void Next() ;
      inline void Prev() ;
      inline void First() ;
      inline void Last() ;

      inline int IsEnd() ;
      inline int IsStart() ;

      inline int SizeList() ;

      inline List operator + (const List& L) ;  
      inline List& operator += (const List& L) ;
      inline List& operator = (const List& L) ;
   } ;


template< class T>
class Stack {
    protected:
        List<T> L ;
    public:
        inline Stack() {} ;
        virtual ~Stack() { L.Destroy() ; } ;

        inline void Push(T* V) ;

        inline T* Pop() ;
} ;

#if 0

template <class T>
class ListWS: public List<T> {
    protected:
        Stack<Node<T> > stack ;
    public:
        inline ListWS() : List<T>() {} ;
        inline ListWS(const ListWS &L) : List<T>(L) { } ;
        virtual ~ListWS() { } ;

        inline void PushPos() ; 
        inline void PopPos() ; 
} ;
#endif
#include "t_list.hpp"

#endif