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
119
120
121
122
123
|
/* This file is part of the FaCT++ DL reasoner
Copyright (C) 2003-2015 Dmitry Tsarkov and The University of Manchester
Copyright (C) 2015-2016 Dmitry Tsarkov
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef TSAVELIST_H
#define TSAVELIST_H
/**
* template list for Saving/Restoring internal state (saving class is template parameter).
* template class should define empty/copy c'tors, member function level()
*/
template <class T>
class TSaveList
{
protected: // internal types
/// type of the list element
class List : public T
{
private: // no copy
/// copy c'tor (unimplemented)
List ( const List& );
/// assignment (unimplemented)
List& operator = ( const List& );
public: // members
/// pointer to next element
List* next;
public: // interface
/// empty c'tor
List ( List* n = NULL ) : next(n) {}
/// create object from given one and from given next
List ( const T& obj, List* n ) : T(obj), next(n) {}
/// d'tor: do nothing
~List ( void ) {}
/// clone given sub-list
List* clone ( void ) { return new List ( *this, next ? next->clone() : NULL ); }
/// clear sub-list
void clear ( void )
{
if ( next )
{
next->clear();
delete next;
}
}
}; // List
protected: // members
/// pointer to head of list
List* head;
public: // interface
/// empty c'tor
TSaveList ( void ) : head(NULL) {}
/// copy c'tor
TSaveList ( const TSaveList& copy ) : head ( copy.head ? copy.head->clone() : NULL ) {}
/// d'tor -- clear stack
~TSaveList ( void ) { clear(); }
// stack operations
/// check that stack is empty
bool empty ( void ) const { return (head == NULL); }
/// put empty element to stack; @return pointer to it
T* push ( void ) { head = new List ( head ); return head; }
/// put given element to stack; @return pointer to it
T* push ( const T& el ) { head = new List ( el, head ); return head; }
/// get top element from stack
T* pop ( void )
{
T* ret = head;
if ( !empty() )
head = head->next;
return ret;
}
/// get element from stack with given level
T* pop ( unsigned int level )
{
List* p = head;
while ( p && p->level() > level )
{
head = p->next;
delete p;
p = head;
}
// here p==head and either both == NULL or points to proper element
if ( p )
head = head->next;
return p;
}
// extra operations
/// clear the stack
void clear ( void )
{
if ( !empty() )
{
head->clear();
delete head;
head = NULL;
}
}
}; // TSaveList
#endif
|
