1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/////////////////////////////////////////////////////////////
// //
// Copyright (c) 2003-2017 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.apache.org/licenses/LICENSE-2.0 //
// //
/////////////////////////////////////////////////////////////
#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 ;
} ;
/*!
List container.
*/
template <class T>
class List
{
protected:
Node<T> *Start ; //!< Pointer to Start of list
Node<T> *End; //!< Pointer to end of list
Node<T> *Current ; //! Pointer to current position in the list
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) ;
} ;
/*!
Stack container.
*/
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
/*!
List container where current position in list can be save
using pop and push.
*/
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() ; //!< Save current position in the list
inline void PopPos() ; //!< restore last saved position in the list
} ;
#endif
#include "t_list.hpp"
#endif
|
