src/foam/containers/HashTables/StaticHashTable/StaticHashTableI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation, either version 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "error.H"
  27 #include "IOstreams.H"
  28
  29 // * * * * * * * * * * * * * Private Member Classes * * * * * * * * * * * * //
  30
  31 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
  32
  33 template<class T, class Key, class Hash>
  34 inline Foam::label
  35 Foam::StaticHashTable<T, Key, Hash>::hashKeyIndex(const Key& key) const
  36 {
  37     // size is power of two - this is the modulus
  38     return Hash()(key) & (keys_.size() - 1);
  39 }
  40
  41
  42 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
  43
  44 template<class T, class Key, class Hash>
  45 inline Foam::label Foam::StaticHashTable<T, Key, Hash>::size() const
  46 {
  47     return nElmts_;
  48 }
  49
  50
  51 template<class T, class Key, class Hash>
  52 inline bool Foam::StaticHashTable<T, Key, Hash>::empty() const
  53 {
  54     return !nElmts_;
  55 }
  56
  57
  58 template<class T, class Key, class Hash>
  59 inline bool Foam::StaticHashTable<T, Key, Hash>::insert
  60 (
  61     const Key& key,
  62     const T& newEntry
  63 )
  64 {
  65     return set(key, newEntry, true);
  66 }
  67
  68
  69 template<class T, class Key, class Hash>
  70 inline bool Foam::StaticHashTable<T, Key, Hash>::set
  71 (
  72     const Key& key,
  73     const T& newEntry
  74 )
  75 {
  76     return set(key, newEntry, false);
  77 }
  78
  79
  80 template<class T, class Key, class Hash>
  81 inline Foam::Xfer<Foam::StaticHashTable<T, Key, Hash> >
  82 Foam::StaticHashTable<T, Key, Hash>::xfer()
  83 {
  84     return xferMove(*this);
  85 }
  86
  87
  88 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
  89
  90 template<class T, class Key, class Hash>
  91 inline T& Foam::StaticHashTable<T, Key, Hash>::operator[](const Key& key)
  92 {
  93     iterator iter = find(key);
  94
  95     if (iter == end())
  96     {
  97         FatalErrorIn("StaticHashTable<T, Key, Hash>::operator[](const Key&)")
  98             << key << " not found in table.  Valid entries: "
  99             << toc()
 100             << exit(FatalError);
 101     }
 102
 103     return *iter;
 104 }
 105
 106
 107 template<class T, class Key, class Hash>
 108 inline const T& Foam::StaticHashTable<T, Key, Hash>::operator[]
 109 (
 110     const Key& key
 111 ) const
 112 {
 113     const_iterator iter = find(key);
 114
 115     if (iter == cend())
 116     {
 117         FatalErrorIn
 118         (
 119             "StaticHashTable<T, Key, Hash>::operator[](const Key&) const"
 120         )   << key << " not found in table.  Valid entries: "
 121             << toc()
 122             << exit(FatalError);
 123     }
 124
 125     return *iter;
 126 }
 127
 128
 129 template<class T, class Key, class Hash>
 130 inline T& Foam::StaticHashTable<T, Key, Hash>::operator()(const Key& key)
 131 {
 132     iterator iter = find(key);
 133
 134     if (iter == end())
 135     {
 136         insert(key, T());
 137         return *find(key);
 138     }
 139     else
 140     {
 141         return *iter;
 142     }
 143 }
 144
 145
 146 // * * * * * * * * * * * * * * * * STL iterator  * * * * * * * * * * * * * * //
 147
 148 template<class T, class Key, class Hash>
 149 template<class TRef, class TableRef>
 150 inline Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::Iterator
 151 (
 152     TableRef hashTbl,
 153     label hashIndex,
 154     label elemIndex
 155 )
 156 :
 157     hashTable_(hashTbl),
 158     hashIndex_(hashIndex),
 159     elemIndex_(elemIndex)
 160 {}
 161
 162
 163 template<class T, class Key, class Hash>
 164 template<class TRef, class TableRef>
 165 inline Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::Iterator
 166 (
 167     const iterator& iter
 168 )
 169 :
 170     hashTable_(iter.hashTable_),
 171     hashIndex_(iter.hashIndex_),
 172     elemIndex_(iter.elemIndex_)
 173 {}
 174
 175
 176 template<class T, class Key, class Hash>
 177 template<class TRef, class TableRef>
 178 inline void
 179 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator=
 180 (
 181     const iterator& iter
 182 )
 183 {
 184     this->hashIndex_ = iter.hashIndex_;
 185     this->elemIndex_ = iter.elemIndex_;
 186 }
 187
 188
 189 template<class T, class Key, class Hash>
 190 template<class TRef, class TableRef>
 191 inline bool
 192 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator==
 193 (
 194     const iterator& iter
 195 ) const
 196 {
 197     return hashIndex_ == iter.hashIndex_ && elemIndex_ == iter.elemIndex_;
 198 }
 199
 200
 201 template<class T, class Key, class Hash>
 202 template<class TRef, class TableRef>
 203 inline bool
 204 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator==
 205 (
 206     const const_iterator& iter
 207 ) const
 208 {
 209     return hashIndex_ == iter.hashIndex_ && elemIndex_ == iter.elemIndex_;
 210 }
 211
 212
 213 template<class T, class Key, class Hash>
 214 template<class TRef, class TableRef>
 215 inline bool
 216 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator!=
 217 (
 218     const iterator& iter
 219 ) const
 220 {
 221     return !operator==(iter);
 222 }
 223
 224
 225 template<class T, class Key, class Hash>
 226 template<class TRef, class TableRef>
 227 inline bool
 228 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator!=
 229 (
 230     const const_iterator& iter
 231 ) const
 232 {
 233     return !operator==(iter);
 234 }
 235
 236
 237 template<class T, class Key, class Hash>
 238 template<class TRef, class TableRef>
 239 inline TRef
 240 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator*()
 241 {
 242     return hashTable_.objects_[hashIndex_][elemIndex_];
 243 }
 244
 245
 246 template<class T, class Key, class Hash>
 247 template<class TRef, class TableRef>
 248 inline TRef
 249 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator()()
 250 {
 251     return operator*();
 252 }
 253
 254
 255 template<class T, class Key, class Hash>
 256 template<class TRef, class TableRef>
 257 inline
 258 typename Foam::StaticHashTable<T, Key, Hash>::template Iterator
 259 <
 260     TRef,
 261     TableRef
 262 >&
 263 Foam::StaticHashTable<T, Key, Hash>::Iterator
 264 <
 265     TRef,
 266     TableRef
 267 >::operator++()
 268 {
 269     // A negative index is a special value from erase
 270     // (see notes in HashTable)
 271     if (hashIndex_ < 0)
 272     {
 273         hashIndex_ = -(hashIndex_+1) - 1;
 274     }
 275     else
 276     {
 277         // Try the next element on the local list
 278         elemIndex_++;
 279
 280         if (elemIndex_ < hashTable_.objects_[hashIndex_].size())
 281         {
 282             return *this;
 283         }
 284     }
 285
 286     // Step to the next table entry
 287     elemIndex_ = 0;
 288
 289     while
 290     (
 291         ++hashIndex_ < hashTable_.objects_.size()
 292      && !hashTable_.objects_[hashIndex_].size()
 293     )
 294     {}
 295
 296
 297     if (hashIndex_ >= hashTable_.objects_.size())
 298     {
 299         // make end iterator
 300         hashIndex_ = hashTable_.keys_.size();
 301     }
 302
 303     return *this;
 304 }
 305
 306
 307 template<class T, class Key, class Hash>
 308 template<class TRef, class TableRef>
 309 inline
 310 typename Foam::StaticHashTable<T, Key, Hash>::template Iterator
 311 <
 312     TRef,
 313     TableRef
 314 >
 315 Foam::StaticHashTable<T, Key, Hash>::Iterator
 316 <
 317     TRef,
 318     TableRef
 319 >::operator++
 320 (
 321     int
 322 )
 323 {
 324     iterator tmp = *this;
 325     ++*this;
 326     return tmp;
 327 }
 328
 329
 330 template<class T, class Key, class Hash>
 331 template<class TRef, class TableRef>
 332 inline const Key&
 333 Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::key() const
 334 {
 335     return hashTable_.keys_[hashIndex_][elemIndex_];
 336 }
 337
 338
 339 template<class T, class Key, class Hash>
 340 inline typename Foam::StaticHashTable<T, Key, Hash>::iterator
 341 Foam::StaticHashTable<T, Key, Hash>::begin()
 342 {
 343     // Find first non-empty entry
 344     forAll(keys_, hashIdx)
 345     {
 346         if (keys_[hashIdx].size())
 347         {
 348             return iterator(*this, hashIdx, 0);
 349         }
 350     }
 351
 352 #   ifdef FULLDEBUG
 353     if (debug)
 354     {
 355         Info<< "StaticHashTable is empty\n";
 356     }
 357 #   endif
 358
 359     return StaticHashTable<T, Key, Hash>::endIter_;
 360 }
 361
 362
 363 template<class T, class Key, class Hash>
 364 inline const typename Foam::StaticHashTable<T, Key, Hash>::iterator&
 365 Foam::StaticHashTable<T, Key, Hash>::end()
 366 {
 367     return StaticHashTable<T, Key, Hash>::endIter_;
 368 }
 369
 370
 371 template<class T, class Key, class Hash>
 372 inline typename Foam::StaticHashTable<T, Key, Hash>::const_iterator
 373 Foam::StaticHashTable<T, Key, Hash>::cbegin() const
 374 {
 375     // Find first non-empty entry
 376     forAll(keys_, hashIdx)
 377     {
 378         if (keys_[hashIdx].size())
 379         {
 380             return const_iterator(*this, hashIdx, 0);
 381         }
 382     }
 383
 384 #   ifdef FULLDEBUG
 385     if (debug)
 386     {
 387         Info<< "StaticHashTable is empty\n";
 388     }
 389 #   endif
 390
 391     return StaticHashTable<T, Key, Hash>::endConstIter_;
 392 }
 393
 394
 395 template<class T, class Key, class Hash>
 396 inline const typename Foam::StaticHashTable<T, Key, Hash>::const_iterator&
 397 Foam::StaticHashTable<T, Key, Hash>::cend() const
 398 {
 399     return StaticHashTable<T, Key, Hash>::endConstIter_;
 400 }
 401
 402
 403 template<class T, class Key, class Hash>
 404 inline typename Foam::StaticHashTable<T, Key, Hash>::const_iterator
 405 Foam::StaticHashTable<T, Key, Hash>::begin() const
 406 {
 407     return this->cbegin();
 408 }
 409
 410
 411 template<class T, class Key, class Hash>
 412 inline const typename Foam::StaticHashTable<T, Key, Hash>::const_iterator&
 413 Foam::StaticHashTable<T, Key, Hash>::end() const
 414 {
 415     return StaticHashTable<T, Key, Hash>::endConstIter_;
 416 }
 417
 418
 419 // ************************************************************************* //