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 TNAMESET_H
#define TNAMESET_H
#include <string>
#include <map>
/// base class for creating Named Entries; template parameter should be derived from TNamedEntry
template<class T>
class TNameCreator
{
public: // interface
/// empty c'tor
TNameCreator ( void ) {}
/// empty d'tor
virtual ~TNameCreator ( void ) {}
/// create new Named Entry
virtual T* makeEntry ( const std::string& name ) const { return new T(name); }
}; // TNameCreator
/// Implementation of NameSets by binary trees; template parameter should be derived from TNamedEntry
template<class T>
class TNameSet
{
protected: // types
/// base type
typedef std::map <std::string, T*> NameTree;
/// RO iterator
typedef typename NameTree::const_iterator const_iterator;
public: // types
/// RW iterator
typedef typename NameTree::iterator iterator;
protected: // members
/// Base holding all names
NameTree Base;
/// creator of new name
TNameCreator<T>* Creator;
private: // no copy
/// no copy c'tor
TNameSet ( const TNameSet& );
/// no assignment
TNameSet& operator = ( const TNameSet& );
public: // interface
/// c'tor (empty)
TNameSet ( void ) : Creator(new TNameCreator<T>) {}
/// c'tor (with given Name Creating class)
TNameSet ( TNameCreator<T>* p ) : Creator(p) {}
/// d'tor (delete all entries)
virtual ~TNameSet ( void ) { clear(); delete Creator; }
/// return pointer to existing id or NULL if no such id defined
T* get ( const std::string& id ) const
{
const_iterator p = Base.find(id);
return p == Base.end() ? NULL : p->second;
}
/// unconditionally add new element with name ID to the set; return new element
T* add ( const std::string& id )
{
T* pne = Creator->makeEntry(id);
Base[id] = pne;
return pne;
}
/// Insert id to a nameset (if necessary); @return pointer to id structure created by external creator
T* insert ( const std::string& id )
{
T* pne = get(id);
if ( pne == NULL ) // no such Id
pne = add(id);
return pne;
}
/// remove given entry from the set
void remove ( const std::string& id )
{
iterator p = Base.find(id);
if ( p != Base.end () ) // founs such Id
{
delete p->second;
Base.erase(p);
}
}
/// clear name set
void clear ( void )
{
for ( iterator p = Base.begin(); p != Base.end(); ++p )
delete p->second;
Base.clear();
}
/// get size of a name set
size_t size ( void ) const { return Base.size(); }
/// RW begin iterator
iterator begin ( void ) { return Base.begin(); }
/// RW end iterator
iterator end ( void ) { return Base.end(); }
}; // TNameSet
#endif
|
