zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ENH: HashTable/HashSet contains(key) method

Browse Source 
- functionality provided as 'found(key)' in OpenFOAM naming, since
  there was no stl equivalent at the time. Now support contains(),
  which is the equivalent for C++20 maps/sets.

STYLE: general contains() method for containers

STYLE: treat Enum and Switch similarly as hash-like objects
This commit is contained in:
Mark Olesen
2023-02-06 11:21:15 +01:00
parent ed39ee6afe
commit 750381bd99
36 changed files with 212 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/OpenFOAM/containers/Bits/bitSet/bitSet.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018-2022 OpenCFD Ltd.
Copyright (C) 2018-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -260,15 +260,17 @@ public:
// \note Method name compatibility with boost::dynamic_bitset
bool intersects(const bitSet& other) const;
//- Test value at specified position, never auto-vivify entries.
//- Test for \em True value at specified position,
//- never auto-vivify entries.
//
// \note Method name compatibility with std::bitset
inline bool test(const label pos) const;
bool test(const label pos) const { return this->get(pos); }
//- Test value at specified position, never auto-vivify entries.
//- Test for \em True value at specified position,
//- never auto-vivify entries.
//
// \note Method name compatibility with HashSet
inline bool found(const label pos) const;
bool contains(const label pos) const { return this->get(pos); }
//- Locate the first bit that is set.
// \return the location or -1 if there are no bits set.
@ -611,6 +613,9 @@ public:
// Housekeeping
//- Same as contains()
bool found(const label pos) const { return this->contains(pos); }
//- Deprecated(2020-11) use fill()
// \deprecated(2020-11) use fill()
void assign(const unsigned int val) { this->fill(val); }

12
src/OpenFOAM/containers/Bits/bitSet/bitSetI.H
View File

@ -518,18 +518,6 @@ inline unsigned int Foam::bitSet::count(const bool on) const
}
inline bool Foam::bitSet::test(const label pos) const
{
return get(pos);
}
inline bool Foam::bitSet::found(const label pos) const
{
return get(pos);
}
inline Foam::labelList Foam::bitSet::sortedToc() const
{
return toc();

14
src/OpenFOAM/containers/Buffers/CircularBuffer.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2022 OpenCFD Ltd.
Copyright (C) 2022-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -288,11 +288,11 @@ public:
// \return position in list or -1 if not found.
label find(const T& val, label pos = 0) const;
//- True if the value if found in the list.
//- Is the value contained in the list?
// Linear search from start pos until the end of the list.
// Any occurrences before the start pos are ignored.
// Linear search.
// \return true if found.
inline bool found(const T& val, label pos = 0) const;
inline bool contains(const T& val, label pos = 0) const;
// Stack-like Operations
@ -480,6 +480,12 @@ public:
// Housekeeping
//- Same as contains()
bool found(const T& val, label pos = 0) const
{
return contains(val, pos);
}
//- Access the first element (front). Requires !empty().
//FOAM_DEPRECATED_FOR(2022-10, "front()")
T& first() { return front(); }

6
src/OpenFOAM/containers/Buffers/CircularBufferI.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2022 OpenCFD Ltd.
Copyright (C) 2022-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -256,7 +256,7 @@ inline void Foam::CircularBuffer<T>::reserve_nocopy(const label len)
template<class T>
inline bool Foam::CircularBuffer<T>::found(const T& val, label pos) const
inline bool Foam::CircularBuffer<T>::contains(const T& val, label pos) const
{
return (this->find(val, pos) >= 0);
}
@ -395,7 +395,7 @@ inline void Foam::CircularBuffer<T>::pop_back(label n)
template<class T>
inline Foam::label Foam::CircularBuffer<T>::push_uniq(const T& val)
{
if (this->found(val))
if (this->contains(val))
{
return 0;
}

8
src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019-2022 OpenCFD Ltd.
Copyright (C) 2019-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -87,9 +87,9 @@ Foam::DictionaryBase<IDLListType, T>::DictionaryBase(Istream& is)
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class IDLListType, class T>
bool Foam::DictionaryBase<IDLListType, T>::found(const word& keyword) const
bool Foam::DictionaryBase<IDLListType, T>::contains(const word& keyword) const
{
return hashedTs_.found(keyword);
return hashedTs_.contains(keyword);
}
@ -217,7 +217,7 @@ T* Foam::DictionaryBase<IDLListType, T>::remove(const word& keyword)
if (iter.found())
{
T* ptr = IDLListType::remove(iter());
T* ptr = IDLListType::remove(iter.val());
hashedTs_.erase(iter);
return ptr;
}

7
src/OpenFOAM/containers/Dictionaries/DictionaryBase/DictionaryBase.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2020-2022 OpenCFD Ltd.
Copyright (C) 2020-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -114,7 +114,7 @@ public:
// Search and lookup
//- Search for given keyword
bool found(const word& keyword) const;
bool contains(const word& keyword) const;
//- Find and return an entry, nullptr on failure.
const T* cfind(const word& keyword) const;
@ -188,6 +188,9 @@ public:
// Housekeeping
//- Same as contains()
bool found(const word& key) const { return this->contains(key); }
//- Deprecated(2020-03) use cfind()
// \deprecated(2020-03) - use cfind() method
FOAM_DEPRECATED_FOR(2020-03, "cfind() method")

2
src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableI.H
View File

@ -87,7 +87,7 @@ inline bool Foam::HashPtrTable<T, Key, Hash>::emplace
// Use insertion semantics
return
(
!parent_type::found(key)
!parent_type::contains(key)
&& this->parent_type::set(key, new T(std::forward<Args>(args)...))
);
}

12
src/OpenFOAM/containers/HashTables/HashSet/HashSet.C
View File

@ -237,14 +237,14 @@ inline Foam::label Foam::HashSet<Key, Hash>::unset
template<class Key, class Hash>
inline bool Foam::HashSet<Key, Hash>::operator()(const Key& key) const noexcept
{
return this->found(key);
return this->contains(key);
}
template<class Key, class Hash>
inline bool Foam::HashSet<Key, Hash>::operator[](const Key& key) const noexcept
{
return this->found(key);
return this->contains(key);
}
@ -281,7 +281,7 @@ bool Foam::HashSet<Key, Hash>::operator==(const HashSet<Key, Hash>& rhs) const
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
if (!this->found(iter.key()))
if (!this->contains(iter.key()))
{
return false;
}
@ -328,7 +328,7 @@ Foam::HashSet<Key, Hash>::operator^=(const HashSet<Key, Hash>& rhs)
// Add missed rhs elements, remove duplicate elements
for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
{
if (this->found(iter.key()))
if (this->contains(iter.key()))
{
this->erase(iter.key());
}
@ -395,7 +395,7 @@ Foam::HashSet<Key, Hash> Foam::operator&
for (const Key& k : a)
{
if (b.found(k))
if (b.contains(k))
{
result.insert(k);
}
@ -429,7 +429,7 @@ Foam::HashSet<Key, Hash> Foam::operator-
for (const Key& k : a)
{
if (!b.found(k))
if (!b.contains(k))
{
result.insert(k);
}

10
src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2016-2021 OpenCFD Ltd.
Copyright (C) 2016-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -176,11 +176,11 @@ public:
// Member Functions
//- Same as found() - return true if key exists in the set.
//- Same as contains() - return true if key exists in the set.
// Method name compatibility with bitSet and boolList.
bool test(const Key& key) const
{
return this->found(key);
return this->contains(key);
}
@ -322,11 +322,11 @@ public:
// Member Operators
//- Return true if the entry exists, same as found()
//- Return true if the entry exists, same as contains()
// \note this allows use of HashSet as a predicate test
inline bool operator()(const Key& key) const noexcept;
//- Return true if the entry exists, same as found().
//- Return true if the entry exists, same as contains().
inline bool operator[](const Key& key) const noexcept;
//- Copy assign

4
src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
View File

@ -553,7 +553,7 @@ Foam::label Foam::HashTable<T, Key, Hash>::erase
++iter
)
{
if (other.found(iter.key()) && erase(iter))
if (other.contains(iter.key()) && erase(iter))
{
++changed;
}
@ -586,7 +586,7 @@ Foam::label Foam::HashTable<T, Key, Hash>::retain
for (iterator iter = begin(); iter != end(); ++iter)
{
if (!other.found(iter.key()) && erase(iter))
if (!other.contains(iter.key()) && erase(iter))
{
++changed;
}

41
src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2022 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -57,7 +57,7 @@ Note
forAllConstIters(table, iter)
{
Info<< "val:" << *iter << nl
<< "key:" << iter.key() << nl;
<< "key:" << iter.key() << nl
<< "val:" << iter.val() << nl;
}
\endcode
@ -213,18 +213,6 @@ private:
Ostream& writeTable(Ostream& os) const;
protected:
//- Internally used base for iterator and const_iterator
template<bool Const> class Iterator;
//- An iterator with const access to HashTable internals.
friend class Iterator<true>;
//- An iterator with non-const access to HashTable internals.
friend class Iterator<false>;
public:
// Constructors
@ -272,8 +260,8 @@ public:
//- Find and return a hashed entry. FatalError if it does not exist.
inline const T& at(const Key& key) const;
//- True if hashed key is found in table
inline bool found(const Key& key) const;
//- True if hashed key is contained (found) in table
inline bool contains(const Key& key) const;
//- Find and return an iterator set at the hashed entry
// If not found iterator = end()
@ -548,9 +536,11 @@ public:
// Member Operators
//- Find and return a hashed entry. FatalError if it does not exist.
// Same as at().
inline T& operator[](const Key& key);
//- Find and return a hashed entry. FatalError if it does not exist.
// Same as at().
inline const T& operator[](const Key& key) const;
//- Return existing entry or create a new entry.
@ -586,6 +576,15 @@ protected:
// Iterators and helpers
//- Internally used base for iterator and const_iterator
template<bool Const> class Iterator;
//- Allow iterator access to HashTable internals.
friend class Iterator<true>;
//- Allow iterator access to HashTable internals.
friend class Iterator<false>;
//- The iterator base for HashTable (internal use only).
// Note: data and functions are protected, to allow reuse by iterator
// and prevent most external usage.
@ -908,13 +907,13 @@ public:
reference operator*() const { return this->key(); }
reference operator()() const { return this->key(); }
inline key_iterator_base& operator++()
key_iterator_base& operator++()
{
this->increment();
return *this;
}
inline key_iterator_base operator++(int)
key_iterator_base operator++(int)
{
key_iterator_base iter(*this);
this->increment();
@ -981,6 +980,12 @@ public:
Ostream&,
const HashTable<T, Key, Hash>& tbl
);
// Housekeeping
//- Same as contains()
bool found(const Key& key) const { return this->contains(key); }
};

4
src/OpenFOAM/containers/HashTables/HashTable/HashTableI.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2020 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -76,7 +76,7 @@ inline const T& Foam::HashTable<T, Key, Hash>::at(const Key& key) const
template<class T, class Key, class Hash>
inline bool Foam::HashTable<T, Key, Hash>::found(const Key& key) const
inline bool Foam::HashTable<T, Key, Hash>::contains(const Key& key) const
{
if (size_)
{

15
src/OpenFOAM/containers/IndirectLists/IndirectListBase/IndirectListBase.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2022 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -191,10 +191,11 @@ public:
// \return -1 if not found.
label rfind(const T& val, label pos = -1) const;
//- True if the value if found in the list.
//- Is the value contained in the list?
// Linear search from start pos until the end of the list.
// Any occurrences before the start pos are ignored.
// Linear search.
inline bool found(const T& val, label pos=0) const;
// \return true if found.
inline bool contains(const T& val, label pos = 0) const;
// Member Operators
@ -382,6 +383,12 @@ public:
//- Access last element of the list, position [size()-1]
//FOAM_DEPRECATED_FOR(2022-10, "back()")
const T& last() const { return back(); };
//- Same as contains()
bool found(const T& val, label pos = 0) const
{
return this->contains(val, pos);
}
};

4
src/OpenFOAM/containers/IndirectLists/IndirectListBase/IndirectListBaseI.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018-2022 OpenCFD Ltd.
Copyright (C) 2018-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -99,7 +99,7 @@ inline bool Foam::IndirectListBase<T, Addr>::uniform() const
template<class T, class Addr>
inline bool Foam::IndirectListBase<T, Addr>::found
inline bool Foam::IndirectListBase<T, Addr>::contains
(
const T& val,
label pos

2
src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
View File

@ -661,7 +661,7 @@ inline void Foam::DynamicList<T, SizeMin>::push_back
template<class T, int SizeMin>
inline Foam::label Foam::DynamicList<T, SizeMin>::push_uniq(const T& val)
{
if (this->found(val))
if (this->contains(val))
{
return 0;
}

15
src/OpenFOAM/containers/Lists/FixedList/FixedList.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2022 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -293,10 +293,11 @@ public:
// \return position in list or -1 if not found.
label rfind(const T& val, label pos = -1) const;
//- True if the value if found in the list.
//- Is the value contained in the list?
// Linear search from start pos until the end of the list.
// Any occurrences before the start pos are ignored.
// Linear search.
inline bool found(const T& val, label pos = 0) const;
// \return true if found.
inline bool contains(const T& val, label pos = 0) const;
// Edit
@ -522,6 +523,12 @@ public:
//- Access last element of the list, position [N-1] - back()
const T& last() const noexcept { return back(); }
//- Same as contains()
bool found(const T& val, label pos = 0) const
{
return this->contains(val, pos);
}
};

8
src/OpenFOAM/containers/Lists/FixedList/FixedListI.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2021 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -345,11 +345,7 @@ inline bool Foam::FixedList<T, N>::uniform() const
template<class T, unsigned N>
inline bool Foam::FixedList<T, N>::found
(
const T& val,
label pos
) const
inline bool Foam::FixedList<T, N>::contains(const T& val, label pos) const
{
return (this->find(val, pos) >= 0);
}

2
src/OpenFOAM/containers/Lists/List/ListI.H
View File

@ -248,7 +248,7 @@ inline void Foam::List<T>::push_back(const IndirectListBase<T, Addr>& list)
template<class T>
inline Foam::label Foam::List<T>::push_uniq(const T& val)
{
if (this->found(val))
if (this->contains(val))
{
return 0;
}

12
src/OpenFOAM/containers/Lists/List/UList.H
View File

@ -325,11 +325,11 @@ public:
// \return position in list or -1 if not found.
label rfind(const T& val, label pos = -1) const;
//- True if the value if found in the list.
//- Is the value contained in the list?
// Linear search from start pos until the end of the list.
// Any occurrences before the start pos are ignored.
// Linear search.
// \return true if found.
inline bool found(const T& val, label pos = 0) const;
inline bool contains(const T& val, label pos = 0) const;
// Edit
@ -611,6 +611,12 @@ public:
//- Access last element of the list, position [size()-1]
//FOAM_DEPRECATED_FOR(2022-10, "back()")
const T& last() const { return back(); };
//- Same as contains()
bool found(const T& val, label pos = 0) const
{
return this->contains(val, pos);
}
};

2
src/OpenFOAM/containers/Lists/List/UListI.H
View File

@ -262,7 +262,7 @@ inline std::streamsize Foam::UList<T>::size_bytes() const noexcept
template<class T>
inline bool Foam::UList<T>::found(const T& val, label pos) const
inline bool Foam::UList<T>::contains(const T& val, label pos) const
{
return (this->find(val, pos) >= 0);
}

5
src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2015-2022 OpenCFD Ltd.
Copyright (C) 2015-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -1095,7 +1095,8 @@ void Foam::ListOps::uniqueEqOp<T>::operator()
{
for (const T& val : y)
{
if (!x.found(val))
// --> x.push_uniq(val)
if (!x.contains(val))
{
x.push_back(val);
}

2
src/OpenFOAM/db/objectRegistry/objectRegistry.C
View File

@ -450,7 +450,7 @@ const Foam::regIOobject* Foam::objectRegistry::cfindIOobject
}
bool Foam::objectRegistry::found
bool Foam::objectRegistry::contains
(
const word& name,
const bool recursive

12
src/OpenFOAM/db/objectRegistry/objectRegistry.H
View File

@ -413,11 +413,11 @@ public:
const bool recursive = false
) const;
//- Can the regIOobject object be found (by name).
//- Does the registry contain the regIOobject object (by name).
//
// \param name the object name
// \param recursive search parent registries
bool found(const word& name, const bool recursive = false) const;
bool contains(const word& name, const bool recursive = false) const;
//- Is the named Type found?
//
@ -591,6 +591,12 @@ public:
// Housekeeping
//- Same as contains()
bool found(const word& name, bool recursive = false) const
{
return this->contains(name, recursive);
}
//- Deprecated(2018-10) find object
// \deprecated(2018-10) - use findObject() method
template<class Type>

4
src/OpenFOAM/interpolations/interpolationLookUpTable/interpolationLookUpTable.C
View File

@ -424,9 +424,9 @@ Foam::interpolationLookUpTable<Type>::operator[](const label i) const
template<class Type>
bool Foam::interpolationLookUpTable<Type>::found(const word& fieldName) const
bool Foam::interpolationLookUpTable<Type>::contains(const word& fieldName) const
{
return fieldIndices_.found(fieldName);
return fieldIndices_.contains(fieldName);
}

14
src/OpenFOAM/interpolations/interpolationLookUpTable/interpolationLookUpTable.H
View File

@ -39,8 +39,8 @@ SourceFiles
\*---------------------------------------------------------------------------*/
#ifndef interpolationLookUpTable_H
#define interpolationLookUpTable_H
#ifndef Foam_interpolationLookUpTable_H
#define Foam_interpolationLookUpTable_H
#include "List.H"
#include "ListOps.H"
@ -162,7 +162,7 @@ public:
// Member Functions
//- Return true if the field exists in the table
bool found(const word& fieldName) const;
bool contains(const word& fieldName) const;
//- Return the output list given a single input scalar
const List<scalar>& lookUp(const scalar);
@ -212,6 +212,14 @@ public:
//- Return an element of List<scalar, Type>
scalarField& operator[](const label);
// Housekeeping
//- Same as contains()
bool found(const word& fieldName) const
{
return this->contains(fieldName);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

12
src/OpenFOAM/meshes/meshShapes/edge/edge.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2015 OpenFOAM Foundation
Copyright (C) 2017-2022 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -153,9 +153,9 @@ public:
//- True if the vertices are unique and non-negative.
bool valid() const noexcept { return good(); }
//- Return true if point label is found in edge.
//- Return true if the point label is contained in the edge.
// Always false for a negative label.
inline bool found(const label pointLabel) const;
inline bool contains(const label pointLabel) const;
//- Return local index (0,1) of point label in edge -1 on failure
// Always return -1 for a negative label.
@ -321,6 +321,12 @@ public:
}
};
// Housekeeping
//- Same as contains()
bool found(label vertex) const { return contains(vertex); }
//- Deprecated(2021-04) hashing functor. Use hasher()
// \deprecated(2021-04) - use hasher() functor
template<class Unused=bool>

8
src/OpenFOAM/meshes/meshShapes/edge/edgeI.H
View File

@ -110,7 +110,7 @@ inline bool Foam::edge::good() const noexcept
}
inline bool Foam::edge::found(const label pointLabel) const
inline bool Foam::edge::contains(const label pointLabel) const
{
// -1: always false
return
@ -142,17 +142,17 @@ inline Foam::label Foam::edge::which(const label pointLabel) const
inline bool Foam::edge::connected(const edge& other) const
{
return (other.found(first()) || other.found(second()));
return (other.contains(first()) || other.contains(second()));
}
inline Foam::label Foam::edge::commonVertex(const edge& other) const
{
if (other.found(first()))
if (other.contains(first()))
{
return first();
}
if (other.found(second()))
if (other.contains(second()))
{
return second();
}

4
src/OpenFOAM/meshes/meshShapes/face/faceI.H
View File

@ -209,7 +209,7 @@ inline bool Foam::face::connected(const labelUList& other) const
{
for (const label pointi : *this)
{
if (other.found(pointi))
if (other.contains(pointi))
{
return true;
}
@ -223,7 +223,7 @@ inline bool Foam::face::connected(const FixedList<label, N>& other) const
{
for (const label pointi : *this)
{
if (other.found(pointi))
if (other.contains(pointi))
{
return true;
}

4
src/OpenFOAM/primitives/bools/Switch/Switch.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2022 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -154,7 +154,7 @@ Foam::Switch Foam::Switch::find(const std::string& str)
}
bool Foam::Switch::found(const std::string& str)
bool Foam::Switch::contains(const std::string& str)
{
return (switchType::INVALID != parse(str, false)); // failOnError=false
}

22
src/OpenFOAM/primitives/bools/Switch/Switch.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2022 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -209,13 +209,13 @@ public:
//- A string representation of bool as "false" / "true"
static const char* name(const bool b) noexcept;
//- True if there is a switch type corresponding to the given string.
static bool contains(const std::string& str);
//- Find switchType for the given string, returning as a Switch that
//- can be tested for good() or bad().
static Switch find(const std::string& str);
//- Test if there is a switch type corresponding to the given string.
static bool found(const std::string& str);
// Member Functions
@ -271,6 +271,9 @@ public:
// Housekeeping
//- Same as contains()
static bool found(const std::string& str) { return contains(str); }
//- Deprecated(2020-01) From string with/without bad input test
// \deprecated(2020-01) - confusing syntax, use static find() method
FOAM_DEPRECATED_FOR(2019-02, "static find() method")
@ -281,13 +284,10 @@ public:
FOAM_DEPRECATED_FOR(2019-02, "static find() method")
Switch(const char* str, bool allowBad);
//- Deprecated(2020-01) Use good() method, or static found() method
// \deprecated(2020-01) Use good() method, or static found() method
FOAM_DEPRECATED_FOR(2019-02, "good() or static found() method")
bool valid() const noexcept
{
return good();
}
//- Deprecated(2020-01) Use good() method, or static contains() method
// \deprecated(2020-01) Use good() method, or static contains() method
FOAM_DEPRECATED_FOR(2019-02, "good() or static contains() method")
bool valid() const noexcept { return good(); }
//- Same as getOrAddToDict()
static Switch lookupOrAddToDict

21
src/OpenFOAM/primitives/enums/Enum.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2017-2022 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -139,6 +139,12 @@ public:
// Query
//- True if there is an enumeration corresponding to the given name.
inline bool contains(const word& enumName) const;
//- True if there is a name corresponding to the given enumeration.
inline bool contains(const EnumType e) const;
//- Find the index of the given name.
// \return position in list or -1 if not found.
inline label find(const word& enumName) const;
@ -147,12 +153,6 @@ public:
// \return position in list or -1 if not found.
inline label find(const EnumType e) const;
//- True if there is an enumeration corresponding to the given name.
inline bool found(const word& enumName) const;
//- True if there is a name corresponding to the given enumeration.
inline bool found(const EnumType e) const;
//- The enumeration corresponding to the given name.
// FatalError if not found.
EnumType get(const word& enumName) const;
@ -319,7 +319,6 @@ public:
return getOrDefault(key, dict, deflt, failsafe);
}
//- Deprecated(2020-11) use get() method
// \deprecated(2020-11) - use get() method
FOAM_DEPRECATED_FOR(2020-11, "get() method")
@ -361,6 +360,12 @@ public:
{
push_back(list);
}
//- Same as contains()
bool found(const word& enumName) const { return contains(enumName); }
//- Same as contains()
bool found(const EnumType e) const { return contains(e); }
};

10
src/OpenFOAM/primitives/enums/EnumI.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2017-2021 OpenCFD Ltd.
Copyright (C) 2017-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -100,16 +100,16 @@ inline Foam::label Foam::Enum<EnumType>::find(const EnumType e) const
template<class EnumType>
inline bool Foam::Enum<EnumType>::found(const word& enumName) const
inline bool Foam::Enum<EnumType>::contains(const word& enumName) const
{
return keys_.found(enumName);
return keys_.contains(enumName);
}
template<class EnumType>
inline bool Foam::Enum<EnumType>::found(const EnumType e) const
inline bool Foam::Enum<EnumType>::contains(const EnumType e) const
{
return vals_.found(int(e));
return vals_.contains(int(e));
}

27
src/OpenFOAM/primitives/predicates/scalar/scalarPredicates.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018-2022 OpenCFD Ltd.
Copyright (C) 2018-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -270,7 +270,7 @@ public:
// Search
//- Index of the first match for the value.
//- Index of the first matching test for the value.
// Any occurrences before the start pos are ignored.
// Linear search.
// \return position in list or -1 if not found.
@ -282,23 +282,23 @@ public:
// \return position in list or -1 if not found.
label rfind(const scalar value, label pos = -1) const;
//- True if the value matches any in the list.
//- True if the value matches in the list.
// Linear search from start pos until the end of the list.
// Any occurrences before the start pos are ignored.
// Linear search.
// \return true if found.
inline bool found(const scalar value, label pos=0) const;
inline bool contains(const scalar value, label pos = 0) const;
//- Match any condition in the list.
//- Match \em any condition in the list.
//
// \return True if the value matches any condition in the list.
inline bool match(const scalar value) const;
//- Match any condition in the list.
//- Match \em any condition in the list.
//
// \return True if the value matches any condition in the list.
inline bool matchAny(const scalar value) const;
//- Match all conditions in the list.
//- Match \em all conditions in the list.
//
// \return True if the value matches all conditions in the list.
inline bool matchAll(const scalar value) const;
@ -324,8 +324,17 @@ public:
// Member Operators
//- Identical to found(), match(), for use as a predicate.
//- Identical to contains(), match(), for use as a predicate.
inline bool operator()(const scalar value) const;
// Housekeeping
//- Same as contains()
bool found(const scalar value, label pos = 0) const
{
return this->contains(value, pos);
}
};

4
src/OpenFOAM/primitives/predicates/scalar/scalarPredicatesI.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018-2022 OpenCFD Ltd.
Copyright (C) 2018-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -60,7 +60,7 @@ inline Foam::predicates::scalars::unary Foam::predicates::scalars::operation
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline bool Foam::predicates::scalars::found
inline bool Foam::predicates::scalars::contains
(
const scalar value,
label pos

16
src/OpenFOAM/primitives/strings/lists/hashedWordList.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2016-2022 OpenCFD Ltd.
Copyright (C) 2016-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -142,8 +142,8 @@ public:
// \return position in list or -1 if not found.
inline label find(const word& val) const;
//- True if the value if found in the list (searches the hash).
inline bool found(const word& val) const;
//- Is the value contained in the list (searches the hash).
inline bool contains(const word& val) const;
// Member Operators
@ -156,7 +156,7 @@ public:
// \return position in list or -1 if not found.
inline label operator[](const word& val) const;
//- Check hashed values for the specified name - same as found().
//- Check hashed values for the specified name - same as contains().
// Can be used as a unary predicate.
inline bool operator()(const word& val) const;
@ -181,6 +181,9 @@ public:
// Housekeeping
//- Same as contains(), searches the hash.
bool found(const word& val) const { return this->contains(val); }
//- Append an element if not already in the list.
FOAM_DEPRECATED_FOR(2022-05, "push_uniq method")
void append(const word& val) { this->push_uniq(val); }
@ -192,11 +195,6 @@ public:
//- Append an element if not already in the list.
//FOAM_DEPRECATED_FOR(2022-10, "push_uniq method")
label appendUniq(const word& val) { return this->push_uniq(val); }
//- Deprecated(2019-01) Is the specified name found in the list?
// \deprecated(2019-01) - use found() method
FOAM_DEPRECATED_FOR(2019-01, "found() method")
bool contains(const word& val) const { return this->found(val); }
};

8
src/OpenFOAM/primitives/strings/lists/hashedWordListI.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2016-2022 OpenCFD Ltd.
Copyright (C) 2016-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -130,9 +130,9 @@ inline Foam::label Foam::hashedWordList::find(const word& val) const
}
inline bool Foam::hashedWordList::found(const word& val) const
inline bool Foam::hashedWordList::contains(const word& val) const
{
return lookup().found(val);
return lookup().contains(val);
}
@ -201,7 +201,7 @@ inline Foam::label Foam::hashedWordList::operator[](const word& val) const
inline bool Foam::hashedWordList::operator()(const word& val) const
{
return lookup_.found(val);
return lookup_.contains(val);
}