mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
03d180724b
- provide key_iterator/const_key_iterator for all hashes,
reuse directly for HashSet as iterator/const_iterator, respectively.
- additional keys() method for HashTable that returns a wrapped to
a pair of begin/end const_iterators with additional size/empty
information that allows these to be used directly by anything else
expecting things with begin/end/size. Unfortunately does not yet
work with std::distance().
Example,
for (auto& k : labelHashTable.keys())
{
...
}
357 lines
9.6 KiB
C++
357 lines
9.6 KiB
C++
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / 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.
|
|
-------------------------------------------------------------------------------
|
|
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/>.
|
|
|
|
Class
|
|
Foam::HashSet
|
|
|
|
Description
|
|
A HashTable with keys but without contents.
|
|
|
|
Typedef
|
|
Foam::wordHashSet
|
|
|
|
Description
|
|
A HashSet with (the default) word keys.
|
|
|
|
Typedef
|
|
Foam::labelHashSet
|
|
|
|
Description
|
|
A HashSet with label keys.
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef HashSet_H
|
|
#define HashSet_H
|
|
|
|
#include "HashTable.H"
|
|
#include "nil.H"
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
namespace Foam
|
|
{
|
|
|
|
// Forward declaration of friend functions and operators
|
|
template<class Key, class Hash> class HashSet;
|
|
|
|
template<class Key, class Hash>
|
|
Ostream& operator<<(Ostream& os, const HashSet<Key, Hash>& tbl);
|
|
|
|
|
|
/*---------------------------------------------------------------------------*\
|
|
Class HashSet Declaration
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
template<class Key=word, class Hash=string::hash>
|
|
class HashSet
|
|
:
|
|
public HashTable<nil, Key, Hash>
|
|
{
|
|
// Private Member Functions
|
|
|
|
//- Insert values, using begin/end iterators.
|
|
template<class InputIter>
|
|
inline label insertMultiple
|
|
(
|
|
const InputIter begIter,
|
|
const InputIter endIter
|
|
);
|
|
|
|
//- Assign using begin/end iterators.
|
|
template<class InputIter>
|
|
inline label assignMultiple
|
|
(
|
|
const InputIter begIter,
|
|
const InputIter endIter,
|
|
const label sz
|
|
);
|
|
|
|
|
|
public:
|
|
|
|
//- The template instance used for this HashSet
|
|
typedef HashSet<Key, Hash> this_type;
|
|
|
|
//- The template instance used for the parent HashTable
|
|
typedef HashTable<nil, Key, Hash> parent_type;
|
|
|
|
//- An iterator, returning reference to the key
|
|
using iterator = typename parent_type::key_iterator;
|
|
|
|
//- A const_iterator, returning reference to the key
|
|
using const_iterator = typename parent_type::const_key_iterator;
|
|
|
|
|
|
// Constructors
|
|
|
|
//- Construct given initial size
|
|
HashSet(const label size = 128)
|
|
:
|
|
parent_type(size)
|
|
{}
|
|
|
|
//- Construct from Istream
|
|
HashSet(Istream& is)
|
|
:
|
|
parent_type(is)
|
|
{}
|
|
|
|
//- Construct from UList of Key
|
|
explicit HashSet(const UList<Key>& lst);
|
|
|
|
//- Construct from FixedList of Key
|
|
template<unsigned Size>
|
|
explicit HashSet(const FixedList<Key, Size>& lst);
|
|
|
|
//- Construct from an initializer list of Key
|
|
HashSet(std::initializer_list<Key> lst);
|
|
|
|
//- Construct as copy
|
|
HashSet(const HashSet<Key, Hash>& hs)
|
|
:
|
|
parent_type(hs)
|
|
{}
|
|
|
|
//- Construct by transferring the parameter contents
|
|
HashSet(const Xfer<HashSet<Key, Hash>>& hs)
|
|
:
|
|
parent_type(hs)
|
|
{}
|
|
|
|
//- Construct by transferring the parameter contents
|
|
HashSet(const Xfer<HashTable<nil, Key, Hash>>& hs)
|
|
:
|
|
parent_type(hs)
|
|
{}
|
|
|
|
//- Construct from the keys of another HashTable,
|
|
// the type of values held is arbitrary.
|
|
template<class AnyType, class AnyHash>
|
|
explicit HashSet(const HashTable<AnyType, Key, AnyHash>& tbl);
|
|
|
|
|
|
// Member Functions
|
|
|
|
// Edit
|
|
|
|
//- Insert a new entry
|
|
bool insert(const Key& key)
|
|
{
|
|
return this->parent_type::insert(key, nil());
|
|
}
|
|
|
|
//- Insert keys from the list of Key
|
|
// Return the number of new elements inserted
|
|
label insert(const UList<Key>& lst);
|
|
|
|
//- Insert keys from the list of Key
|
|
// Return the number of new elements inserted
|
|
template<unsigned Size>
|
|
label insert(const FixedList<Key, Size>& lst);
|
|
|
|
//- Insert keys from a initializer list of Key
|
|
// Return the number of new elements inserted
|
|
label insert(std::initializer_list<Key> lst);
|
|
|
|
//- Same as insert (cannot overwrite nil content)
|
|
bool set(const Key& key)
|
|
{
|
|
return insert(key);
|
|
}
|
|
|
|
//- Same as insert (cannot overwrite nil content)
|
|
label set(const UList<Key>& lst)
|
|
{
|
|
return insert(lst);
|
|
}
|
|
|
|
//- Same as insert (cannot overwrite nil content)
|
|
template<unsigned Size>
|
|
label set(const FixedList<Key, Size>& lst)
|
|
{
|
|
return insert(lst);
|
|
}
|
|
|
|
//- Same as insert (cannot overwrite nil content)
|
|
label set(std::initializer_list<Key> lst)
|
|
{
|
|
return insert(lst);
|
|
}
|
|
|
|
//- Unset the specified key - same as erase
|
|
bool unset(const Key& key)
|
|
{
|
|
return this->parent_type::erase(key);
|
|
}
|
|
|
|
//- Unset the listed keys - same as erase
|
|
label unset(const UList<Key>& lst)
|
|
{
|
|
return this->parent_type::erase(lst);
|
|
}
|
|
|
|
//- Unset the listed keys - same as erase
|
|
template<unsigned Size>
|
|
label unset(const FixedList<Key, Size>& lst)
|
|
{
|
|
return this->parent_type::erase(lst);
|
|
}
|
|
|
|
//- Unset the listed keys - same as erase
|
|
label unset(std::initializer_list<Key> lst)
|
|
{
|
|
return this->parent_type::erase(lst);
|
|
}
|
|
|
|
|
|
// STL iterators
|
|
|
|
iterator begin();
|
|
const_iterator begin() const;
|
|
const_iterator cbegin() const;
|
|
|
|
const iterator& end();
|
|
const const_iterator& end() const;
|
|
const const_iterator& cend() const;
|
|
|
|
|
|
// Writing
|
|
|
|
//- Write the unordered keys as a list, with line-breaks if list length
|
|
// exceeds shortListLen. Using '0' suppresses line-breaks entirely.
|
|
Ostream& writeList(Ostream& os, const label shortListLen=0) const
|
|
{
|
|
return this->writeKeys(os, shortListLen);
|
|
}
|
|
|
|
|
|
// Member Operators
|
|
|
|
//- This operation doesn't make much sense for a hash-set
|
|
void operator()(const Key& key) = delete;
|
|
|
|
//- Return true if the entry exists, same as found()
|
|
inline bool operator[](const Key& key) const;
|
|
|
|
//- Equality. Two hashset are equal when they have the same keys.
|
|
// Independent of table size or order.
|
|
bool operator==(const this_type& rhs) const;
|
|
|
|
//- The opposite of the equality operation.
|
|
bool operator!=(const this_type& rhs) const;
|
|
|
|
|
|
//- Assignment from a UList of keys
|
|
void operator=(const UList<Key>& lst);
|
|
|
|
//- Assignment from a FixedList of keys
|
|
template<unsigned Size>
|
|
void operator=(const FixedList<Key, Size>& lst);
|
|
|
|
//- Assignment from an initializer list of keys
|
|
void operator=(std::initializer_list<Key> lst);
|
|
|
|
|
|
//- Combine entries from HashSets
|
|
void operator|=(const HashSet<Key, Hash>& rhs);
|
|
|
|
//- Only retain entries found in both HashSets
|
|
void operator&=(const HashSet<Key, Hash>& rhs);
|
|
|
|
//- Only retain unique entries (xor)
|
|
void operator^=(const HashSet<Key, Hash>& rhs);
|
|
|
|
//- Add entries listed in the given HashSet to this HashSet
|
|
inline void operator+=(const HashSet<Key, Hash>& rhs)
|
|
{
|
|
this->operator|=(rhs);
|
|
}
|
|
|
|
//- Remove entries listed in the given HashSet from this HashSet
|
|
void operator-=(const HashSet<Key, Hash>& rhs);
|
|
|
|
|
|
// IOstream Operator
|
|
|
|
friend Ostream& operator<< <Key, Hash>
|
|
(
|
|
Ostream& os,
|
|
const HashSet<Key, Hash>& tbl
|
|
);
|
|
|
|
};
|
|
|
|
|
|
// Global Operators
|
|
|
|
//- Combine entries from HashSets
|
|
template<class Key, class Hash>
|
|
HashSet<Key,Hash> operator|
|
|
(
|
|
const HashSet<Key,Hash>& hash1,
|
|
const HashSet<Key,Hash>& hash2
|
|
);
|
|
|
|
|
|
//- Create a HashSet that only contains entries found in both HashSets
|
|
template<class Key, class Hash>
|
|
HashSet<Key,Hash> operator&
|
|
(
|
|
const HashSet<Key,Hash>& hash1,
|
|
const HashSet<Key,Hash>& hash2
|
|
);
|
|
|
|
|
|
//- Create a HashSet that only contains unique entries (xor)
|
|
template<class Key, class Hash>
|
|
HashSet<Key,Hash> operator^
|
|
(
|
|
const HashSet<Key,Hash>& hash1,
|
|
const HashSet<Key,Hash>& hash2
|
|
);
|
|
|
|
|
|
//- A HashSet with word keys.
|
|
typedef HashSet<> wordHashSet;
|
|
|
|
//- A HashSet with label keys.
|
|
typedef HashSet<label, Hash<label>> labelHashSet;
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
} // End namespace Foam
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
#ifdef NoRepository
|
|
#include "HashSet.C"
|
|
#endif
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
#endif
|
|
|
|
// ************************************************************************* //
|