mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
69918f23c5
- OSspecific: chmod() -> chMod(), even although it's not used anywhere - ListOps get subset() and inplaceSubset() templated on BoolListType - added UList<bool>::operator[](..) const specialization. Returns false (actually pTraits<bool>::zero) for out-of-range elements. This lets us use List<bool> with lazy evaluation and no noticeable change in performance. - use rcIndex() and fcIndex() wherever possible. Could check if branching or modulus is faster for fcIndex(). - UList and FixedList get 'const T* cdata() const' and 'T* data()' members. Similar to the STL front() and std::string::data() methods, they return a pointer to the first element without needing to write '&myList[0]', recast begin() or violate const-ness.
407 lines
9.2 KiB
C++
407 lines
9.2 KiB
C++
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
\\ / O peration |
|
|
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
|
|
\\/ M anipulation |
|
|
-------------------------------------------------------------------------------
|
|
License
|
|
This file is part of OpenFOAM.
|
|
|
|
OpenFOAM is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License as published by the
|
|
Free Software Foundation; either version 2 of the License, or (at your
|
|
option) any later version.
|
|
|
|
OpenFOAM 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 General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenFOAM; if not, write to the Free Software Foundation,
|
|
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
#include "error.H"
|
|
#include "IOstreams.H"
|
|
|
|
// * * * * * * * * * * * * * Private Member Classes * * * * * * * * * * * * //
|
|
|
|
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline Foam::label Foam::StaticHashTable<T, Key, Hash>::size() const
|
|
{
|
|
return nElmts_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline bool Foam::StaticHashTable<T, Key, Hash>::empty() const
|
|
{
|
|
return !nElmts_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline bool Foam::StaticHashTable<T, Key, Hash>::insert
|
|
(
|
|
const Key& key,
|
|
const T& newEntry
|
|
)
|
|
{
|
|
return set(key, newEntry, true);
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline bool Foam::StaticHashTable<T, Key, Hash>::set
|
|
(
|
|
const Key& key,
|
|
const T& newEntry
|
|
)
|
|
{
|
|
return set(key, newEntry, false);
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline Foam::Xfer<Foam::StaticHashTable<T, Key, Hash> >
|
|
Foam::StaticHashTable<T, Key, Hash>::xfer()
|
|
{
|
|
return xferMove(*this);
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline T& Foam::StaticHashTable<T, Key, Hash>::operator[](const Key& key)
|
|
{
|
|
iterator iter = find(key);
|
|
|
|
if (iter == end())
|
|
{
|
|
FatalErrorIn("StaticHashTable<T, Key, Hash>::operator[](const Key&)")
|
|
<< key << " not found in table. Valid entries: "
|
|
<< toc()
|
|
<< exit(FatalError);
|
|
}
|
|
|
|
return *iter;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline const T& Foam::StaticHashTable<T, Key, Hash>::operator[]
|
|
(
|
|
const Key& key
|
|
) const
|
|
{
|
|
const_iterator iter = find(key);
|
|
|
|
if (iter == end())
|
|
{
|
|
FatalErrorIn
|
|
(
|
|
"StaticHashTable<T, Key, Hash>::operator[](const Key&) const"
|
|
) << key << " not found in table. Valid entries: "
|
|
<< toc()
|
|
<< exit(FatalError);
|
|
}
|
|
|
|
return *iter;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline T& Foam::StaticHashTable<T, Key, Hash>::operator()(const Key& key)
|
|
{
|
|
iterator iter = find(key);
|
|
|
|
if (iter == end())
|
|
{
|
|
insert(key, T());
|
|
return *find(key);
|
|
}
|
|
else
|
|
{
|
|
return *iter;
|
|
}
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * STL iterator * * * * * * * * * * * * * * //
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::Iterator
|
|
(
|
|
TableRef curHashTable,
|
|
label hashIndex,
|
|
label elementIndex
|
|
)
|
|
:
|
|
curHashTable_(curHashTable),
|
|
hashIndex_(hashIndex),
|
|
elementIndex_(elementIndex)
|
|
{}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::Iterator
|
|
(
|
|
const iterator& iter
|
|
)
|
|
:
|
|
curHashTable_(iter.curHashTable_),
|
|
hashIndex_(iter.hashIndex_),
|
|
elementIndex_(iter.elementIndex_)
|
|
{}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline void
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator=
|
|
(
|
|
const iterator& iter
|
|
)
|
|
{
|
|
this->hashIndex_ = iter.hashIndex_;
|
|
this->elementIndex_ = iter.elementIndex_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline bool
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator==
|
|
(
|
|
const iterator& iter
|
|
) const
|
|
{
|
|
return hashIndex_ == iter.hashIndex_ && elementIndex_ == iter.elementIndex_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline bool
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator==
|
|
(
|
|
const const_iterator& iter
|
|
) const
|
|
{
|
|
return hashIndex_ == iter.hashIndex_ && elementIndex_ == iter.elementIndex_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline bool
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator!=
|
|
(
|
|
const iterator& iter
|
|
) const
|
|
{
|
|
return !operator==(iter);
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline bool
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator!=
|
|
(
|
|
const const_iterator& iter
|
|
) const
|
|
{
|
|
return !operator==(iter);
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline TRef
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator*()
|
|
{
|
|
return curHashTable_.objects_[hashIndex_][elementIndex_];
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline TRef
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::operator()()
|
|
{
|
|
return operator*();
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline
|
|
typename Foam::StaticHashTable<T, Key, Hash>::template Iterator
|
|
<
|
|
TRef,
|
|
TableRef
|
|
>&
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator
|
|
<
|
|
TRef,
|
|
TableRef
|
|
>::operator++()
|
|
{
|
|
// Check for special value from erase. (sets hashIndex to -1)
|
|
if (hashIndex_ >= 0)
|
|
{
|
|
// Try the next element on the local list
|
|
elementIndex_++;
|
|
|
|
if (elementIndex_ < curHashTable_.objects_[hashIndex_].size())
|
|
{
|
|
return *this;
|
|
}
|
|
}
|
|
|
|
// Step to the next table entry
|
|
elementIndex_ = 0;
|
|
|
|
while
|
|
(
|
|
++hashIndex_ < curHashTable_.objects_.size()
|
|
&& !curHashTable_.objects_[hashIndex_].size()
|
|
)
|
|
{}
|
|
|
|
|
|
if (hashIndex_ >= curHashTable_.objects_.size())
|
|
{
|
|
// make end iterator
|
|
hashIndex_ = curHashTable_.keys_.size();
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline
|
|
typename Foam::StaticHashTable<T, Key, Hash>::template Iterator
|
|
<
|
|
TRef,
|
|
TableRef
|
|
>
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator
|
|
<
|
|
TRef,
|
|
TableRef
|
|
>::operator++
|
|
(
|
|
int
|
|
)
|
|
{
|
|
iterator tmp = *this;
|
|
++*this;
|
|
return tmp;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
template<class TRef, class TableRef>
|
|
inline const Key&
|
|
Foam::StaticHashTable<T, Key, Hash>::Iterator<TRef, TableRef>::key()
|
|
{
|
|
return curHashTable_.keys_[hashIndex_][elementIndex_];
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline typename Foam::StaticHashTable<T, Key, Hash>::iterator
|
|
Foam::StaticHashTable<T, Key, Hash>::begin()
|
|
{
|
|
// Find first non-empty entry
|
|
forAll(keys_, hashIdx)
|
|
{
|
|
if (keys_[hashIdx].size())
|
|
{
|
|
return iterator(*this, hashIdx, 0);
|
|
}
|
|
}
|
|
|
|
# ifdef FULLDEBUG
|
|
if (debug)
|
|
{
|
|
Info<< "StaticHashTable is empty\n";
|
|
}
|
|
# endif
|
|
|
|
return StaticHashTable<T, Key, Hash>::endIter_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline const typename Foam::StaticHashTable<T, Key, Hash>::iterator&
|
|
Foam::StaticHashTable<T, Key, Hash>::end()
|
|
{
|
|
return StaticHashTable<T, Key, Hash>::endIter_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline typename Foam::StaticHashTable<T, Key, Hash>::const_iterator
|
|
Foam::StaticHashTable<T, Key, Hash>::cbegin() const
|
|
{
|
|
// Find first non-empty entry
|
|
forAll(keys_, hashIdx)
|
|
{
|
|
if (keys_[hashIdx].size())
|
|
{
|
|
return const_iterator(*this, hashIdx, 0);
|
|
}
|
|
}
|
|
|
|
# ifdef FULLDEBUG
|
|
if (debug)
|
|
{
|
|
Info<< "StaticHashTable is empty\n";
|
|
}
|
|
# endif
|
|
|
|
return StaticHashTable<T, Key, Hash>::endConstIter_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline const typename Foam::StaticHashTable<T, Key, Hash>::const_iterator&
|
|
Foam::StaticHashTable<T, Key, Hash>::cend() const
|
|
{
|
|
return StaticHashTable<T, Key, Hash>::endConstIter_;
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline typename Foam::StaticHashTable<T, Key, Hash>::const_iterator
|
|
Foam::StaticHashTable<T, Key, Hash>::begin() const
|
|
{
|
|
return this->cbegin();
|
|
}
|
|
|
|
|
|
template<class T, class Key, class Hash>
|
|
inline const typename Foam::StaticHashTable<T, Key, Hash>::const_iterator&
|
|
Foam::StaticHashTable<T, Key, Hash>::end() const
|
|
{
|
|
return StaticHashTable<T, Key, Hash>::endConstIter_;
|
|
}
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
// ************************************************************************* //
|