mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
ENH: make hashedWordList movable
This commit is contained in:
Mark Olesen
3
applications/test/hashedWordList/Make/files
Normal file
3
applications/test/hashedWordList/Make/files
Normal file
@ -0,0 +1,3 @@
|
||||
Test-hashedWordList.C
|
||||
|
||||
EXE = $(FOAM_USER_APPBIN)/Test-hashedWordList
|
||||
2
applications/test/hashedWordList/Make/options
Normal file
2
applications/test/hashedWordList/Make/options
Normal file
@ -0,0 +1,2 @@
|
||||
/* EXE_INC = -I$(LIB_SRC)/cfdTools/include */
|
||||
/* EXE_LIBS = -lfiniteVolume */
|
||||
181
applications/test/hashedWordList/Test-hashedWordList.C
Normal file
181
applications/test/hashedWordList/Test-hashedWordList.C
Normal file
@ -0,0 +1,181 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2018 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 3 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, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Description
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "IOstreams.H"
|
||||
#include "ITstream.H"
|
||||
#include "FlatOutput.H"
|
||||
#include "hashedWordList.H"
|
||||
|
||||
using namespace Foam;
|
||||
|
||||
Ostream& printInfo(const hashedWordList& list, bool withAddr=false)
|
||||
{
|
||||
Info<< flatOutput(list) << nl << list.lookup() << nl;
|
||||
if (withAddr)
|
||||
{
|
||||
Info<< "addr=" << long(list.cdata()) << nl;
|
||||
}
|
||||
|
||||
return Info;
|
||||
}
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
// Main program:
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
Info<< "Test hashedWordList" << nl;
|
||||
|
||||
hashedWordList list1
|
||||
{
|
||||
"this",
|
||||
"is",
|
||||
"a",
|
||||
"list",
|
||||
"of",
|
||||
"words",
|
||||
};
|
||||
|
||||
Info<<nl << "From initializer_list" << nl;
|
||||
printInfo(list1, true);
|
||||
|
||||
list1.sort();
|
||||
|
||||
Info<<nl << "sorted" << nl;
|
||||
printInfo(list1, true);
|
||||
|
||||
// Copy construct
|
||||
hashedWordList list2(list1);
|
||||
|
||||
Info<<nl << "Copy construct" << nl;
|
||||
Info<<"list1: ";
|
||||
printInfo(list1, true);
|
||||
Info<<"list2: ";
|
||||
printInfo(list2, true);
|
||||
|
||||
// Move construct
|
||||
hashedWordList list3(std::move(list1));
|
||||
|
||||
Info<<nl << "Move construct" << nl;
|
||||
Info<<"list1: ";
|
||||
printInfo(list1, true);
|
||||
Info<<"list3: ";
|
||||
printInfo(list3, true);
|
||||
|
||||
// Move assign
|
||||
list1 = std::move(list3);
|
||||
|
||||
Info<<nl << "Move assign" << nl;
|
||||
Info<<"list1: ";
|
||||
printInfo(list1, true);
|
||||
Info<<"list3: ";
|
||||
printInfo(list3, true);
|
||||
|
||||
list1.swap(list3);
|
||||
Info<<nl << "Swap" << nl;
|
||||
Info<<"list1: ";
|
||||
printInfo(list1, true);
|
||||
Info<<"list3: ";
|
||||
printInfo(list3, true);
|
||||
|
||||
wordList wlist1
|
||||
{
|
||||
"plain", "list", "with", "some", "with", "list", "duplicates"
|
||||
};
|
||||
|
||||
|
||||
// Copy construct unique
|
||||
hashedWordList list4(wlist1, true);
|
||||
|
||||
Info<<nl << "Copy construct unique" << nl;
|
||||
Info<<"words: " << flatOutput(wlist1) << nl;
|
||||
Info<<"list4: ";
|
||||
printInfo(list4, false);
|
||||
|
||||
// Move construct unique
|
||||
hashedWordList list5(std::move(wlist1), true);
|
||||
|
||||
Info<<nl << "Move construct unique" << nl;
|
||||
Info<<"words: " << flatOutput(wlist1) << nl;
|
||||
Info<<"list5: ";
|
||||
printInfo(list5, false);
|
||||
|
||||
// Move back. Leaves lookup() with some rubbish, but clean that later
|
||||
wlist1 = std::move(list5);
|
||||
|
||||
Info<<nl << "Move to wordList" << nl;
|
||||
Info<<"words: " << flatOutput(wlist1) << nl;
|
||||
Info<<"list5: ";
|
||||
printInfo(list5, false);
|
||||
|
||||
// Move back. Leaves lookup() with some rubbish, but clean that later
|
||||
list5 = std::move(wlist1);
|
||||
|
||||
Info<<nl << "Moved from wordList" << nl;
|
||||
Info<<"words: " << flatOutput(wlist1) << nl;
|
||||
Info<<"list5: ";
|
||||
printInfo(list5, false);
|
||||
|
||||
|
||||
// Test access:
|
||||
|
||||
Info<<nl << "Access" << nl;
|
||||
Info<<"list: " << flatOutput(list5) << nl;
|
||||
|
||||
for (const auto str : { "some", "list", "of", "words" })
|
||||
{
|
||||
Info<<"index of " << str << " = " << list5[str] << nl;
|
||||
}
|
||||
|
||||
// Stream construct
|
||||
{
|
||||
ITstream input
|
||||
(
|
||||
"input",
|
||||
"(plain list with some with list duplicates)"
|
||||
);
|
||||
|
||||
hashedWordList list6(input);
|
||||
|
||||
Info<<nl << "Construct from stream" << nl;
|
||||
Info<<"list: " << flatOutput(list6) << nl;
|
||||
|
||||
input.rewind();
|
||||
|
||||
input >> list4;
|
||||
Info<<nl << "re-read from stream" << nl;
|
||||
Info<<"list: " << flatOutput(list4) << nl;
|
||||
}
|
||||
|
||||
|
||||
Info<< "\nEnd\n";
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -2,8 +2,8 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation | Copyright (C) 2016-2017 OpenCFD Ltd.
|
||||
\\ / A nd | Copyright (C) 2016-2018 OpenCFD Ltd.
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
@ -24,118 +24,73 @@ License
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "hashedWordList.H"
|
||||
#include "CStringList.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
Foam::hashedWordList::hashedWordList
|
||||
(
|
||||
const label count,
|
||||
const char** lst,
|
||||
const bool removeDuplicates
|
||||
const label len,
|
||||
const char** array,
|
||||
bool unique
|
||||
)
|
||||
:
|
||||
List<word>(count)
|
||||
wordList(len)
|
||||
{
|
||||
forAll(*this, i)
|
||||
for (label i=0; i < len; ++i)
|
||||
{
|
||||
List<word>::operator[](i) = lst[i];
|
||||
wordList::operator[](i) = array[i];
|
||||
}
|
||||
|
||||
rehash(removeDuplicates);
|
||||
rehash(unique);
|
||||
}
|
||||
|
||||
|
||||
Foam::hashedWordList::hashedWordList
|
||||
(
|
||||
const char** lst,
|
||||
const bool removeDuplicates
|
||||
)
|
||||
{
|
||||
// Determine the number of entries
|
||||
label count = 0;
|
||||
for (unsigned i = 0; lst[i] && *(lst[i]); ++i)
|
||||
{
|
||||
++count;
|
||||
}
|
||||
|
||||
List<word>::setSize(count);
|
||||
forAll(*this, i)
|
||||
{
|
||||
List<word>::operator[](i) = lst[i];
|
||||
}
|
||||
|
||||
rehash(removeDuplicates);
|
||||
}
|
||||
Foam::hashedWordList::hashedWordList(const char** array, bool unique)
|
||||
:
|
||||
hashedWordList(CStringList::count(array), array, unique)
|
||||
{}
|
||||
|
||||
|
||||
Foam::hashedWordList::hashedWordList(Istream& is)
|
||||
{
|
||||
is >> *this;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
|
||||
|
||||
void Foam::hashedWordList::transfer
|
||||
(
|
||||
List<word>& lst,
|
||||
const bool removeDuplicates
|
||||
)
|
||||
{
|
||||
List<word>::transfer(lst);
|
||||
rehash(removeDuplicates);
|
||||
}
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
void Foam::hashedWordList::rehash() const
|
||||
{
|
||||
indices_.clear();
|
||||
lookup_.clear();
|
||||
|
||||
forAll(*this, i)
|
||||
const wordUList& list = *this;
|
||||
const label len = list.size();
|
||||
|
||||
for (label i=0; i < len; ++i)
|
||||
{
|
||||
indices_.insert(List<word>::operator[](i), i);
|
||||
lookup_.insert(list[i], i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Foam::hashedWordList::uniq()
|
||||
{
|
||||
indices_.clear();
|
||||
lookup_.clear();
|
||||
|
||||
label nElem = 0;
|
||||
forAll(*this, i)
|
||||
wordList& list = *this;
|
||||
const label len = list.size();
|
||||
|
||||
label count = 0;
|
||||
for (label i=0; i < len; ++i)
|
||||
{
|
||||
const word& item = List<word>::operator[](i);
|
||||
word& item = list[i];
|
||||
|
||||
if (indices_.insert(item, nElem))
|
||||
if (lookup_.insert(item, i))
|
||||
{
|
||||
if (nElem != i)
|
||||
if (count != i)
|
||||
{
|
||||
List<word>::operator[](nElem) = item;
|
||||
list[count] = std::move(item);
|
||||
}
|
||||
++nElem;
|
||||
++count;
|
||||
}
|
||||
}
|
||||
|
||||
List<word>::setSize(nElem);
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
|
||||
|
||||
Foam::Istream& Foam::operator>>(Istream& is, hashedWordList& lst)
|
||||
{
|
||||
is >> static_cast<List<word>&>(lst);
|
||||
lst.rehash();
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
Foam::Ostream& Foam::operator<<(Ostream& os, const hashedWordList& lst)
|
||||
{
|
||||
os << static_cast<const UList<word>&>(lst);
|
||||
return os;
|
||||
list.resize(count);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -25,7 +25,8 @@ Class
|
||||
Foam::hashedWordList
|
||||
|
||||
Description
|
||||
A wordList with hashed indices for additional fast lookup by name.
|
||||
A wordList with hashed named lookup, which can be faster in some
|
||||
situations than using the normal list find/found methods.
|
||||
|
||||
SourceFiles
|
||||
hashedWordListI.H
|
||||
@ -44,11 +45,9 @@ SourceFiles
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// Forward declarations
|
||||
class hashedWordList;
|
||||
|
||||
// Forward declaration of friend functions and operators
|
||||
Istream& operator>>(Istream& is, hashedWordList& lst);
|
||||
Ostream& operator<<(Ostream& os, const hashedWordList& lst);
|
||||
inline Istream& operator>>(Istream& is, hashedWordList& lst);
|
||||
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
@ -57,44 +56,34 @@ Ostream& operator<<(Ostream& os, const hashedWordList& lst);
|
||||
|
||||
class hashedWordList
|
||||
:
|
||||
public List<word>
|
||||
public wordList
|
||||
{
|
||||
// Private data
|
||||
// Private Data
|
||||
|
||||
//- Hash of words/indices
|
||||
mutable HashTable<label> indices_;
|
||||
|
||||
|
||||
// Private Member Functions
|
||||
|
||||
//- Rebuild the lookup hash or make unique entries first.
|
||||
inline void rehash(const bool unique);
|
||||
//- Lookup HashTable of words vs list-indices
|
||||
mutable HashTable<label> lookup_;
|
||||
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct null
|
||||
inline hashedWordList();
|
||||
//- Construct an empty list
|
||||
inline hashedWordList() = default;
|
||||
|
||||
//- Copy constructor.
|
||||
//- Copy construct.
|
||||
inline hashedWordList(const hashedWordList& lst);
|
||||
|
||||
//- Construct from list of words,
|
||||
// optionally eliminating duplicates
|
||||
inline hashedWordList
|
||||
(
|
||||
const UList<word>& lst,
|
||||
const bool removeDuplicates=false
|
||||
);
|
||||
//- Move construct.
|
||||
inline hashedWordList(hashedWordList&& lst);
|
||||
|
||||
//- Construct by transferring the parameter contents,
|
||||
// optionally eliminating duplicates
|
||||
inline hashedWordList
|
||||
(
|
||||
const Xfer<List<word>>& lst,
|
||||
const bool removeDuplicates=false
|
||||
);
|
||||
//- Copy construct from list of words
|
||||
inline explicit hashedWordList(const wordUList& lst);
|
||||
|
||||
//- Copy construct from list of words, eliminating duplicates
|
||||
inline hashedWordList(const wordUList& lst, bool unique);
|
||||
|
||||
//- Move construct from list of words, optionally eliminating duplicates
|
||||
inline hashedWordList(wordList&& lst, bool unique=false);
|
||||
|
||||
//- Construct from an initializer list
|
||||
inline hashedWordList(std::initializer_list<word> lst);
|
||||
@ -110,19 +99,14 @@ public:
|
||||
|
||||
//- Construct from number and list of words,
|
||||
// optionally eliminating duplicates
|
||||
hashedWordList
|
||||
(
|
||||
const label count,
|
||||
const char** lst,
|
||||
const bool removeDuplicates=false
|
||||
);
|
||||
hashedWordList(const label len, const char** array, bool unique=false);
|
||||
|
||||
//- Construct from a nullptr-terminated list of words,
|
||||
// optionally eliminating duplicates
|
||||
hashedWordList(const char** lst, const bool removeDuplicates=false);
|
||||
hashedWordList(const char** array, bool unique=false);
|
||||
|
||||
//- Construct from Istream
|
||||
hashedWordList(Istream& is);
|
||||
inline hashedWordList(Istream& is);
|
||||
|
||||
|
||||
// Member Functions
|
||||
@ -132,7 +116,7 @@ public:
|
||||
|
||||
//- Append an element at the end of the list,
|
||||
// optionally avoid append if it would be a duplicate entry
|
||||
inline void append(const word& name, const bool avoidDuplicates=false);
|
||||
inline void append(const word& name, bool unique=false);
|
||||
|
||||
//- Does the list contain the specified name
|
||||
inline bool found(const word& name) const;
|
||||
@ -143,51 +127,64 @@ public:
|
||||
//- Return the hash of words/indices for inspection
|
||||
inline const HashTable<label>& lookup() const;
|
||||
|
||||
//- Swap contents
|
||||
inline void swap(hashedWordList& lst);
|
||||
|
||||
//- Transfer contents of the argument into this list
|
||||
//- and annul the argument list, optionally eliminating duplicates
|
||||
inline void transfer(hashedWordList& lst);
|
||||
|
||||
//- Transfer the contents of the argument List into this list
|
||||
// and annul the argument list,
|
||||
// optionally eliminating duplicates
|
||||
void transfer(List<word>& lst, const bool removeDuplicates=false);
|
||||
//- and annul the argument list, optionally eliminating duplicates
|
||||
inline void transfer(wordList& lst, bool unique=false);
|
||||
|
||||
//- Rebuild the lookup hash indices
|
||||
void rehash() const;
|
||||
|
||||
//- Rebuild the lookup hash indices, or make unique entries first.
|
||||
inline void rehash(bool unique);
|
||||
|
||||
//- Adjust the list (if needed) to eliminate duplicate entries,
|
||||
//- and rehash the indices
|
||||
void uniq();
|
||||
|
||||
//- Sort the list and rehash the indices
|
||||
inline void sort();
|
||||
|
||||
//- Adjust the list if necessary to eliminate duplicate entries,
|
||||
// and rehash the indices
|
||||
void uniq();
|
||||
|
||||
|
||||
// Member Operators
|
||||
|
||||
//- Return name corresponding to specified index
|
||||
//- Return name corresponding to specified index.
|
||||
// Fatal for out of range values.
|
||||
inline const word& operator[](const label index) const;
|
||||
|
||||
//- Return index corresponding to specified name, or -1 on failure
|
||||
inline label operator[](const word& name) const;
|
||||
|
||||
//- Does the list contain the specified name - same as found.
|
||||
// Makes hashedWordList suitable as a unary predicate.
|
||||
//- Check hashed values for the specified name - same as found.
|
||||
// Can be used as a unary predicate.
|
||||
inline bool operator()(const word& name) const;
|
||||
|
||||
|
||||
// Assignment
|
||||
|
||||
//- Assignment operator from list of words. Rehashes the indices.
|
||||
inline void operator=(const UList<word>& lst);
|
||||
|
||||
//- Assignment operator from initializer list. Rehashes the indices.
|
||||
inline void operator=(std::initializer_list<word> lst);
|
||||
|
||||
//- Assignment operator. Rehashes the indices.
|
||||
//- Copy assignment. Rehashes the indices.
|
||||
inline void operator=(const hashedWordList& lst);
|
||||
|
||||
//- Copy assignment from list of words. Rehashes the indices.
|
||||
inline void operator=(const wordUList& lst);
|
||||
|
||||
// Istream operators
|
||||
//- Copy assignment from initializer list. Rehashes the indices.
|
||||
inline void operator=(std::initializer_list<word> lst);
|
||||
|
||||
friend Istream& operator>>(Istream& is, hashedWordList& lst);
|
||||
friend Ostream& operator<<(Ostream& os, const hashedWordList& lst);
|
||||
//- Move assignment operator.
|
||||
inline void operator=(hashedWordList&& lst);
|
||||
|
||||
//- Move assignment from list of words. Rehashes the indices.
|
||||
inline void operator=(wordList&& lst);
|
||||
|
||||
//- Read from an input stream. Rehashes the indices.
|
||||
inline friend Istream& operator>>(Istream& is, hashedWordList& lst);
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -2,8 +2,8 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation | Copyright (C) 2016-2017 OpenCFD Ltd.
|
||||
\\ / A nd | Copyright (C) 2016-2018 OpenCFD Ltd.
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
@ -23,64 +23,46 @@ License
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
||||
|
||||
inline void Foam::hashedWordList::rehash(const bool unique)
|
||||
{
|
||||
if (unique)
|
||||
{
|
||||
uniq();
|
||||
}
|
||||
else
|
||||
{
|
||||
rehash();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList()
|
||||
:
|
||||
List<word>()
|
||||
{}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList(const hashedWordList& lst)
|
||||
:
|
||||
List<word>(static_cast<const UList<word>&>(lst))
|
||||
hashedWordList(static_cast<const wordUList&>(lst), false)
|
||||
{}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList(hashedWordList&& lst)
|
||||
:
|
||||
wordList(std::move(static_cast<wordList&>(lst))),
|
||||
lookup_(std::move(lst.lookup_))
|
||||
{}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList(const wordUList& lst)
|
||||
:
|
||||
hashedWordList(lst, false)
|
||||
{}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList(const wordUList& lst, bool unique)
|
||||
:
|
||||
wordList(lst)
|
||||
{
|
||||
rehash();
|
||||
rehash(unique);
|
||||
}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList
|
||||
(
|
||||
const UList<word>& lst,
|
||||
const bool removeDuplicates
|
||||
)
|
||||
inline Foam::hashedWordList::hashedWordList(wordList&& lst, bool unique)
|
||||
:
|
||||
List<word>(lst)
|
||||
wordList(std::move(lst))
|
||||
{
|
||||
rehash(removeDuplicates);
|
||||
}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList
|
||||
(
|
||||
const Xfer<List<word>>& lst,
|
||||
const bool removeDuplicates
|
||||
)
|
||||
:
|
||||
List<word>(lst)
|
||||
{
|
||||
rehash(removeDuplicates);
|
||||
rehash(unique);
|
||||
}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList(std::initializer_list<word> lst)
|
||||
:
|
||||
List<word>(lst)
|
||||
wordList(lst)
|
||||
{
|
||||
rehash();
|
||||
}
|
||||
@ -92,37 +74,41 @@ inline Foam::hashedWordList::hashedWordList
|
||||
const HashTable<AnyType, word, AnyHash>& tbl
|
||||
)
|
||||
:
|
||||
List<word>(tbl.size())
|
||||
wordList(tbl.size())
|
||||
{
|
||||
wordList& list = *this;
|
||||
|
||||
label count = 0;
|
||||
for (auto iter = tbl.cbegin(); iter != tbl.cend(); ++iter)
|
||||
{
|
||||
List<word>::operator[](count++) = iter.key();
|
||||
list[count++] = iter.key();
|
||||
}
|
||||
|
||||
this->sort();
|
||||
}
|
||||
|
||||
|
||||
inline Foam::hashedWordList::hashedWordList(Istream& is)
|
||||
{
|
||||
is >> *this;
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
inline void Foam::hashedWordList::clear()
|
||||
{
|
||||
List<word>::clear();
|
||||
indices_.clear();
|
||||
wordList::clear();
|
||||
lookup_.clear();
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::append
|
||||
(
|
||||
const word& name,
|
||||
const bool avoidDuplicates
|
||||
)
|
||||
inline void Foam::hashedWordList::append(const word& name, bool unique)
|
||||
{
|
||||
// name is either unique or we don't care about duplicates
|
||||
if (indices_.insert(name, size()) || !avoidDuplicates)
|
||||
if (lookup_.insert(name, size()) || !unique)
|
||||
{
|
||||
List<word>::append(name);
|
||||
wordList::append(name);
|
||||
}
|
||||
}
|
||||
|
||||
@ -130,19 +116,64 @@ inline void Foam::hashedWordList::append
|
||||
inline const Foam::HashTable<Foam::label>&
|
||||
Foam::hashedWordList::lookup() const
|
||||
{
|
||||
return indices_;
|
||||
const label lenList = wordList::size();
|
||||
const label lenHash = lookup_.size();
|
||||
|
||||
if ((lenList < lenHash) || (lenList && !lenHash))
|
||||
{
|
||||
rehash(); // Was somehow out of sync
|
||||
}
|
||||
|
||||
return lookup_;
|
||||
}
|
||||
|
||||
|
||||
inline bool Foam::hashedWordList::found(const word& name) const
|
||||
{
|
||||
return indices_.found(name);
|
||||
return lookup().found(name);
|
||||
}
|
||||
|
||||
|
||||
inline bool Foam::hashedWordList::contains(const word& name) const
|
||||
{
|
||||
return indices_.found(name);
|
||||
return lookup().found(name);
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::swap(hashedWordList& lst)
|
||||
{
|
||||
wordList::swap(static_cast<wordList&>(lst));
|
||||
lookup_.swap(lst.lookup_);
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::transfer
|
||||
(
|
||||
hashedWordList& lst
|
||||
)
|
||||
{
|
||||
wordList::transfer(static_cast<wordList&>(lst));
|
||||
lookup_.transfer(lst.lookup_);
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::transfer(wordList& lst, bool unique)
|
||||
{
|
||||
wordList::transfer(lst);
|
||||
rehash(unique);
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::rehash(bool unique)
|
||||
{
|
||||
if (unique)
|
||||
{
|
||||
uniq();
|
||||
}
|
||||
else
|
||||
{
|
||||
rehash();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -160,46 +191,65 @@ inline const Foam::word& Foam::hashedWordList::operator[]
|
||||
const label index
|
||||
) const
|
||||
{
|
||||
return List<word>::operator[](index);
|
||||
return wordList::operator[](index);
|
||||
}
|
||||
|
||||
|
||||
inline Foam::label Foam::hashedWordList::operator[](const word& name) const
|
||||
{
|
||||
auto iter = indices_.find(name);
|
||||
|
||||
if (iter.found())
|
||||
{
|
||||
return iter.object();
|
||||
}
|
||||
|
||||
return -1; // Not found (or not hashed?)
|
||||
return lookup_.lookup(name, -1); // -1 = not found or not hashed
|
||||
}
|
||||
|
||||
|
||||
inline bool Foam::hashedWordList::operator()(const word& name) const
|
||||
{
|
||||
return indices_.found(name);
|
||||
return lookup_.found(name);
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::operator=(const UList<word>& lst)
|
||||
inline void Foam::hashedWordList::operator=(const hashedWordList& lst)
|
||||
{
|
||||
List<word>::operator=(lst);
|
||||
wordList::operator=(lst);
|
||||
rehash();
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::operator=(const wordUList& lst)
|
||||
{
|
||||
wordList::operator=(lst);
|
||||
rehash();
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::operator=(std::initializer_list<word> lst)
|
||||
{
|
||||
List<word>::operator=(lst);
|
||||
wordList::operator=(lst);
|
||||
rehash();
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::operator=(const hashedWordList& lst)
|
||||
inline void Foam::hashedWordList::operator=(hashedWordList&& lst)
|
||||
{
|
||||
operator=(static_cast<const UList<word>&>(lst));
|
||||
wordList::operator=(std::move(static_cast<wordList&>(lst)));
|
||||
lookup_ = std::move(lst.lookup_);
|
||||
}
|
||||
|
||||
|
||||
inline void Foam::hashedWordList::operator=(wordList&& lst)
|
||||
{
|
||||
wordList::operator=(std::move(lst));
|
||||
rehash();
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
|
||||
|
||||
inline Foam::Istream& Foam::operator>>(Istream& is, hashedWordList& lst)
|
||||
{
|
||||
is >> static_cast<wordList&>(lst);
|
||||
lst.rehash();
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user