ListHashTableI.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 \*---------------------------------------------------------------------------*/
25 
26 #include "IOstreams.H"
27 
28 // * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
29 
30 template<class T, class Key, class Hash>
31 inline Foam::label
33 {
34  // size is power of two - this is the modulus
35  return Hash()(key) & (keys_.size() - 1);
36 }
37 
38 
39 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
40 
41 template<class T, class Key, class Hash>
43 {
44  return nElmts_;
45 }
46 
47 
48 template<class T, class Key, class Hash>
50 {
51  return !nElmts_;
52 }
53 
54 
55 template<class T, class Key, class Hash>
57 (
58  const Key& key,
59  const T& newEntry
60 )
61 {
62  return set(key, newEntry, true);
63 }
64 
65 
66 template<class T, class Key, class Hash>
68 (
69  const Key& key,
70  const T& newEntry
71 )
72 {
73  return set(key, newEntry, false);
74 }
75 
76 
77 // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
78 
79 template<class T, class Key, class Hash>
81 {
82  iterator iter = find(key);
83 
84  if (iter == end())
85  {
87  << toc()
88  << exit(FatalError);
89  }
90 
91  return *iter;
92 }
93 
94 
95 template<class T, class Key, class Hash>
97 (
98  const Key& key
99 ) const
100 {
101  const_iterator iter = find(key);
102 
103  if (iter == cend())
104  {
106  << toc()
107  << exit(FatalError);
108  }
109 
110  return *iter;
111 }
112 
113 
114 template<class T, class Key, class Hash>
116 {
117  iterator iter = find(key);
118 
119  if (iter == end())
120  {
121  insert(key, T());
122  return *find(key);
123  }
124  else
125  {
126  return *iter;
127  }
128 }
129 
130 
131 // * * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * //
132 
133 template<class T, class Key, class Hash>
134 template<class TRef, class TableRef>
136 (
137  TableRef hashTbl,
138  label hashIndex,
139  label elemIndex
140 )
141 :
142  hashTable_(hashTbl),
143  hashIndex_(hashIndex),
144  elemIndex_(elemIndex)
145 {}
146 
147 
148 template<class T, class Key, class Hash>
149 template<class TRef, class TableRef>
151 (
152  const iterator& iter
153 )
154 :
155  hashTable_(iter.hashTable_),
156  hashIndex_(iter.hashIndex_),
157  elemIndex_(iter.elemIndex_)
158 {}
159 
160 
161 template<class T, class Key, class Hash>
162 template<class TRef, class TableRef>
163 inline void
165 (
166  const iterator& iter
167 )
168 {
169  this->hashIndex_ = iter.hashIndex_;
170  this->elemIndex_ = iter.elemIndex_;
171 }
172 
173 
174 template<class T, class Key, class Hash>
175 template<class TRef, class TableRef>
176 inline bool
178 (
179  const iterator& iter
180 ) const
181 {
182  return hashIndex_ == iter.hashIndex_ && elemIndex_ == iter.elemIndex_;
183 }
184 
185 
186 template<class T, class Key, class Hash>
187 template<class TRef, class TableRef>
188 inline bool
190 (
191  const const_iterator& iter
192 ) const
193 {
194  return hashIndex_ == iter.hashIndex_ && elemIndex_ == iter.elemIndex_;
195 }
196 
197 
198 template<class T, class Key, class Hash>
199 template<class TRef, class TableRef>
200 inline bool
202 (
203  const iterator& iter
204 ) const
205 {
206  return !operator==(iter);
207 }
208 
209 
210 template<class T, class Key, class Hash>
211 template<class TRef, class TableRef>
212 inline bool
214 (
215  const const_iterator& iter
216 ) const
217 {
218  return !operator==(iter);
219 }
220 
221 
222 template<class T, class Key, class Hash>
223 template<class TRef, class TableRef>
224 inline TRef
226 {
227  return hashTable_.objects_[hashIndex_][elemIndex_];
228 }
229 
230 
231 template<class T, class Key, class Hash>
232 template<class TRef, class TableRef>
233 inline TRef
235 {
236  return operator*();
237 }
238 
239 
240 template<class T, class Key, class Hash>
241 template<class TRef, class TableRef>
242 inline
244 <
245  TRef,
246  TableRef
247 >&
249 <
250  TRef,
251  TableRef
253 {
254  // A negative index is a special value from erase
255  // (see notes in HashTable)
256  if (hashIndex_ < 0)
257  {
258  hashIndex_ = -(hashIndex_+1) - 1;
259  }
260  else
261  {
262  // Try the next element on the local list
263  elemIndex_++;
264 
265  if (elemIndex_ < hashTable_.objects_[hashIndex_].size())
266  {
267  return *this;
268  }
269  }
270 
271  // Step to the next table entry
272  elemIndex_ = 0;
273 
274  while
275  (
276  ++hashIndex_ < hashTable_.objects_.size()
277  && !hashTable_.objects_[hashIndex_].size()
278  )
279  {}
280 
281 
282  if (hashIndex_ >= hashTable_.objects_.size())
283  {
284  // make end iterator
285  hashIndex_ = hashTable_.keys_.size();
286  }
287 
288  return *this;
289 }
290 
291 
292 template<class T, class Key, class Hash>
293 template<class TRef, class TableRef>
294 inline
296 <
297  TRef,
298  TableRef
299 >
301 <
302  TRef,
303  TableRef
305 (
306  int
307 )
308 {
309  iterator tmp = *this;
310  ++*this;
311  return tmp;
312 }
313 
314 
315 template<class T, class Key, class Hash>
316 template<class TRef, class TableRef>
317 inline const Key&
319 {
320  return hashTable_.keys_[hashIndex_][elemIndex_];
321 }
322 
323 
324 template<class T, class Key, class Hash>
327 {
328  // Find first non-empty entry
329  forAll(keys_, hashIdx)
330  {
331  if (keys_[hashIdx].size())
332  {
333  return iterator(*this, hashIdx, 0);
334  }
335  }
336 
337  #ifdef FULLDEBUG
338  if (debug)
339  {
340  Info<< "ListHashTable is empty\n";
341  }
342  #endif
343 
345 }
346 
347 
348 template<class T, class Key, class Hash>
349 inline const typename Foam::ListHashTable<T, Key, Hash>::iterator&
351 {
353 }
354 
355 
356 template<class T, class Key, class Hash>
359 {
360  // Find first non-empty entry
361  forAll(keys_, hashIdx)
362  {
363  if (keys_[hashIdx].size())
364  {
365  return const_iterator(*this, hashIdx, 0);
366  }
367  }
368 
369  #ifdef FULLDEBUG
370  if (debug)
371  {
372  Info<< "ListHashTable is empty\n";
373  }
374  #endif
375 
377 }
378 
379 
380 template<class T, class Key, class Hash>
383 {
385 }
386 
387 
388 template<class T, class Key, class Hash>
391 {
392  return this->cbegin();
393 }
394 
395 
396 template<class T, class Key, class Hash>
399 {
401 }
402 
403 
404 // ************************************************************************* //
Useful combination of include files which define Sin, Sout and Serr and the use of IO streams general...
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:434
STL conforming hash table using contiguous lists rather than linked lists.
T & operator[](const Key &)
Find and return an hashed entry.
bool insert(const Key &key, const T &newElmt)
Insert a new hashed entry.
const_iterator cbegin() const
const_iterator set to the beginning of the ListHashTable
friend Ostream & operator(Ostream &, const ListHashTable< T, Key, Hash > &)
Iterator< T &, ListHashTable< T, Key, Hash > & > iterator
const const_iterator & cend() const
const_iterator set to beyond the end of the ListHashTable
label size() const
Return number of elements in table.
const iterator & end()
Iterator set to beyond the end of the ListHashTable.
Iterator< const T &, const ListHashTable< T, Key, Hash > & > const_iterator
bool empty() const
Return true if the hash table is empty.
bool operator==(const ListHashTable< T, Key, Hash > &) const
Equality. Two hash tables are equal if all contents of first are.
iterator begin()
Iterator set to the beginning of the ListHashTable.
T & operator()(const Key &)
Find and return an hashed entry, create it null if not present.
A class for managing temporary objects.
Definition: tmp.H:55
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:334
void insert(const scalar, DynamicList< floatScalar > &)
Append scalar to given DynamicList.
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
messageStream Info
tmp< fvMatrix< Type > > operator*(const volScalarField::Internal &, const fvMatrix< Type > &)
error FatalError
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)