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
124
125
126
127
128
129
|
////////////////////////////////////////////////////////////////////////////////
//
// PlainHashSet.hh
// produced: 01/09/97 jr
//
////////////////////////////////////////////////////////////////////////////////
#ifndef PLAINHASHSET_HH
#define PLAINHASHSET_HH
#include <stdlib.h>
#include <iostream>
#include <ctype.h>
#include <string.h>
#include "Global.hh"
#include "RefCount.hh"
#include "PlainHashTable.hh"
namespace topcom {
template<class Key>
class HashSetData;
template<class Key>
class __hsd_reader;
template<class Key>
inline std::istream& operator>>(std::istream& ist, __hsd_reader<Key>& r);
template<class Key>
class __hsd_reader {
public:
Key key;
public:
inline __hsd_reader() : key() {}
friend std::istream& operator>><>(std::istream& ist, __hsd_reader& r);
};
template<class Key>
inline std::ostream& operator<<(std::ostream& ost, const HashSetData<Key>& hsd);
template<class Key>
class HashSetData {
public:
typedef Key key_type;
typedef SmartPtr<Key> keyptr_type;
typedef SmartPtr<const Key> const_keyptr_type;
typedef __hsd_reader<Key> reader;
private:
const const_keyptr_type _keyptr;
public:
// constructors:
inline HashSetData() : _keyptr() {}
inline HashSetData(const HashSetData& hsd) : _keyptr(hsd._keyptr) {}
inline HashSetData(const Key& new_key) : _keyptr(new_key) {}
inline HashSetData(const reader& r) : _keyptr(r.key) {}
// destructor:
inline ~HashSetData() {}
private:
// assignment:
inline HashSetData& operator=(const HashSetData& hsd) {
if (this == &hsd) {
return *this;
}
_keyptr = hsd._keyptr;
return *this;
}
public:
// conversion:
inline operator const Key&() const { return *_keyptr; }
// keys for containers:
inline const keyptr_type& keyptr() const { return _keyptr; }
inline const Key& key() const { return *_keyptr; }
// comparison:
inline const bool operator==(const HashSetData<Key>& hsd) const { return (key() == hsd.key()); }
inline const bool operator!=(const HashSetData<Key>& hsd) const { return !(key() == hsd.key()); }
// iostream:
inline std::ostream& write(std::ostream& ost) const {
return ost << *_keyptr;
}
friend std::ostream& operator<<<>(std::ostream& ost, const HashSetData<Key>& hsd);
};
template<class Key>
class PlainHashSet : public PlainHashTable< HashSetData<Key> > {
public:
typedef PlainHashTable< HashSetData<Key> > plainhashset_data;
typedef typename HashSetData<Key>::keyptr_type keyptr_type;
typedef typename HashSetData<Key>::const_keyptr_type const_keyptr_type;
public:
// constructors:
inline PlainHashSet() : plainhashset_data() {}
inline PlainHashSet(const PlainHashSet& phs) : plainhashset_data(phs) {}
inline PlainHashSet(const plainhashset_data& phsd) : plainhashset_data(phsd) {}
inline PlainHashSet(const size_type init_bucket_count) : plainhashset_data(init_bucket_count) {}
// destructor:
inline ~PlainHashSet() {}
// assignment:
inline PlainHashSet& operator=(const PlainHashSet& phs) {
plainhashset_data::operator=(phs);
return *this;
}
// functions:
inline void insert(const Key& key) { plainhashset_data::insert(key); }
inline bool member(const Key& key) const { return plainhashset_data::member(key); }
};
template<class Key>
inline std::istream& operator>>(std::istream& ist, __hsd_reader<Key>& r) {
if (!(ist >> std::ws >> r.key)) {
#ifdef READ_DEBUG
std::cerr << "std::istream& operator>>(std::istream&, HashMapData<Key, Data>&): "
<< "key not found." << std::endl;
#endif
ist.clear(std::ios::failbit);
return ist;
}
return ist;
}
template<class Key>
inline std::ostream& operator<<(std::ostream& ost, const HashSetData<Key>& hsd) {
return hsd.write(ost);
}
}; // namespace topcom
#endif
// eof PlainHashSet.hh
|
