meshLibrary/utilities/boundaryLayers/boundaryLayers/boundaryLayersCreateVertices.C

@@ -210,7 +210,7 @@ Foam::point Foam::Module::boundaryLayers::createNewVertex
                 bool found(true);
                 forAll(otherPatches, opI)
                 {
-                    if (!pPatches.contains(bpJ, otherPatches[opI]))
+                    if (!pPatches.found(bpJ, otherPatches[opI]))
                     {
                         found = false;
                         break;
@@ -940,7 +940,7 @@ void Foam::Module::boundaryLayers::createNewEdgeVerticesParallel
                 bool found(true);
                 forAll(otherPatches, opI)
                 {
-                    if (!pPatches.contains(bpJ, otherPatches[opI]))
+                    if (!pPatches.found(bpJ, otherPatches[opI]))
                     {
                         found = false;
                         break;

meshLibrary/utilities/boundaryLayers/extrudeLayer/extrudeLayerI.H

@@ -122,7 +122,7 @@ Foam::Module::extrudeLayer::addressingCalculator::faceSharingEdge
             continue;
         }
 
-        if (pointExtruded_.contains(nextI, currFaceI))
+        if (pointExtruded_.found(nextI, currFaceI))
         {
             if (otherFace != -1)
             {
@@ -152,7 +152,7 @@ inline void Foam::Module::extrudeLayer::addressingCalculator::facesSharingEdge
     {
         const label currFaceI = pointExtruded_(start, pfI);
 
-        if (pointExtruded_.contains(end, currFaceI))
+        if (pointExtruded_.found(end, currFaceI))
         {
             edgeFaces.append(currFaceI);
         }

meshLibrary/utilities/boundaryLayers/refineBoundaryLayers/refineBoundaryLayersFaces.C

@@ -487,7 +487,7 @@ void Foam::Module::refineBoundaryLayers::sortFacePoints
         {
             const label nfI = facesFromFace_(faceI, i);
 
-            if ((numSplitsI == 1) && newFaces_.contains(nfI, f.nextLabel(pos)))
+            if ((numSplitsI == 1) && newFaces_.found(nfI, f.nextLabel(pos)))
             {
                 numSplitsI = i + 1;
                 break;
@@ -584,7 +584,7 @@ void Foam::Module::refineBoundaryLayers::sortFacePoints
         {
             const label nfI = facesFromFace_(faceI, j);
 
-            if ((numSplitsJ == 1) && newFaces_.contains(nfI, f.prevLabel(pos)))
+            if ((numSplitsJ == 1) && newFaces_.found(nfI, f.prevLabel(pos)))
             {
                 numSplitsJ = j + 1;
                 break;
@@ -735,7 +735,7 @@ void Foam::Module::refineBoundaryLayers::sortFaceFaces
         {
             const label nfI = facesFromFace_(faceI, i);
 
-            if ((numSplitsI == 1) && newFaces_.contains(nfI, f.nextLabel(pos)))
+            if ((numSplitsI == 1) && newFaces_.found(nfI, f.nextLabel(pos)))
             {
                 numSplitsI = i + 1;
                 break;
@@ -789,7 +789,7 @@ void Foam::Module::refineBoundaryLayers::sortFaceFaces
         {
             const label nfI = facesFromFace_(faceI, j);
 
-            if ((numSplitsJ == 1) && newFaces_.contains(nfI, f.prevLabel(pos)))
+            if ((numSplitsJ == 1) && newFaces_.found(nfI, f.prevLabel(pos)))
             {
                 numSplitsJ = j + 1;
                 break;

meshLibrary/utilities/containers/DynList/DynList.C

@@ -27,8 +27,8 @@ License
 
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
-template<class T, Foam::label staticSize>
-Foam::Module::DynList<T, staticSize>::DynList(Istream&)
+template<class T, int StaticSize>
+Foam::Module::DynList<T, StaticSize>::DynList(Istream&)
 :
     dataPtr_(nullptr),
     nAllocated_(0),
@@ -39,11 +39,11 @@ Foam::Module::DynList<T, staticSize>::DynList(Istream&)
 }
 
 
-template<class T, Foam::label staticSize>
+template<class T, int StaticSize>
 Foam::Ostream& Foam::Module::operator<<
 (
     Foam::Ostream& os,
-    const Foam::Module::DynList<T, staticSize>& DL
+    const Foam::Module::DynList<T, StaticSize>& DL
 )
 {
     UList<T> helper(DL.dataPtr_, DL.nextFree_);
@@ -53,11 +53,11 @@ Foam::Ostream& Foam::Module::operator<<
 }
 
 
-template<class T, Foam::label staticSize>
+template<class T, int StaticSize>
 Foam::Istream& Foam::Module::operator>>
 (
     Foam::Istream& is,
-    Foam::Module::DynList<T, staticSize>& DL
+    Foam::Module::DynList<T, StaticSize>& DL
 )
 {
     NotImplemented;

meshLibrary/utilities/containers/DynList/DynList.H

@@ -50,22 +50,21 @@ namespace Foam
 namespace Module
 {
 
-// Forward declaration of template friend
+// Forward declarations
 
-template<class T, label staticSize>
-class DynList;
+template<class T, int StaticSize> class DynList;
 
-template<class T, label staticSize>
+template<class T, int StaticSize>
 Ostream& operator<<
 (
     Ostream&,
-    const DynList<T, staticSize>&
+    const DynList<T, StaticSize>&
 );
-template<class T, label staticSize>
+template<class T, int StaticSize>
 Istream& operator>>
 (
     Istream&,
-    DynList<T, staticSize>&
+    DynList<T, StaticSize>&
 );
 
 
@@ -73,11 +72,11 @@ Istream& operator>>
                            Class DynList Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class T, Foam::label staticSize = 16>
+template<class T, int StaticSize = 16>
 class DynList
 {
     // Private data
-    //
+
         //- pointer to the data
         T* dataPtr_;
 
@@ -85,7 +84,7 @@ class DynList
         label nAllocated_;
 
         //- statically allocated data (used for short lists)
-        T staticData_[staticSize];
+        T staticData_[StaticSize];
 
         //- Number of next free element
         label nextFree_;
@@ -138,7 +137,7 @@ public:
         inline DynList(const ListType&);
 
         //- Copy constructor
-        inline DynList(const DynList<T, staticSize>&);
+        inline DynList(const DynList<T, StaticSize>&);
 
         //- Construct from Istream. nextFree_ set to size().
         explicit DynList(Istream&);
@@ -223,27 +222,27 @@ public:
         inline void operator=(const T&);
 
         //- Copy of another list
-        inline void operator=(const DynList<T, staticSize>&);
+        inline void operator=(const DynList<T, StaticSize>&);
 
         //- Compare the list with the another one
-        inline bool operator==(const DynList<T, staticSize>&) const;
-        inline bool operator!=(const DynList<T, staticSize>&) const;
+        inline bool operator==(const DynList<T, StaticSize>&) const;
+        inline bool operator!=(const DynList<T, StaticSize>&) const;
 
 
     // IOstream operators
 
         // Write DynList to Ostream.
-        friend Ostream& operator<< <T, staticSize>
+        friend Ostream& operator<< <T, StaticSize>
         (
             Ostream&,
-            const DynList<T, staticSize>&
+            const DynList<T, StaticSize>&
         );
 
         //- Read from Istream, discarding contents of existing DynList.
-        friend Istream& operator>> <T, staticSize>
+        friend Istream& operator>> <T, StaticSize>
         (
             Istream&,
-            DynList<T, staticSize>&
+            DynList<T, StaticSize>&
         );
 };
 

meshLibrary/utilities/containers/DynList/DynListI.H

@@ -23,26 +23,26 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-template<class T, Foam::label staticSize>
-inline T* Foam::Module::DynList<T, staticSize>::data()
+template<class T, int StaticSize>
+inline T* Foam::Module::DynList<T, StaticSize>::data()
 {
     return dataPtr_;
 }
 
 
-template<class T, Foam::label staticSize>
-inline const T* Foam::Module::DynList<T, staticSize>::data() const
+template<class T, int StaticSize>
+inline const T* Foam::Module::DynList<T, StaticSize>::data() const
 {
     return dataPtr_;
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::allocateSize(const label s)
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::allocateSize(const label s)
 {
     checkAllocation();
 
-    if (s > staticSize)
+    if (s > StaticSize)
     {
         if (s > nAllocated_)
         {
@@ -54,7 +54,7 @@ inline void Foam::Module::DynList<T, staticSize>::allocateSize(const label s)
                 newData[i] = this->operator[](i);
             }
 
-            if (nAllocated_ > staticSize)
+            if (nAllocated_ > StaticSize)
             {
                 delete[] dataPtr_;
             }
@@ -80,7 +80,7 @@ inline void Foam::Module::DynList<T, staticSize>::allocateSize(const label s)
     }
     else
     {
-        if (nAllocated_ > staticSize)
+        if (nAllocated_ > StaticSize)
         {
             //- delete dynamically allocated data
             for (label i = 0; i < s; ++i)
@@ -92,13 +92,13 @@ inline void Foam::Module::DynList<T, staticSize>::allocateSize(const label s)
         }
 
         dataPtr_ = staticData_;
-        nAllocated_ = staticSize;
+        nAllocated_ = StaticSize;
     }
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::checkIndex
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::checkIndex
 (
     const label i
 ) const
@@ -112,8 +112,8 @@ inline void Foam::Module::DynList<T, staticSize>::checkIndex
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::checkAllocation() const
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::checkAllocation() const
 {
     if (nextFree_ > nAllocated_)
     {
@@ -126,8 +126,8 @@ inline void Foam::Module::DynList<T, staticSize>::checkAllocation() const
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class T, Foam::label staticSize>
-inline Foam::Module::DynList<T, staticSize>::DynList()
+template<class T, int StaticSize>
+inline Foam::Module::DynList<T, StaticSize>::DynList()
 :
     dataPtr_(nullptr),
     nAllocated_(0),
@@ -143,8 +143,8 @@ inline Foam::Module::DynList<T, staticSize>::DynList()
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::Module::DynList<T, staticSize>::DynList(const label s)
+template<class T, int StaticSize>
+inline Foam::Module::DynList<T, StaticSize>::DynList(const label s)
 :
     dataPtr_(nullptr),
     nAllocated_(0),
@@ -160,8 +160,8 @@ inline Foam::Module::DynList<T, staticSize>::DynList(const label s)
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::Module::DynList<T, staticSize>::DynList
+template<class T, int StaticSize>
+inline Foam::Module::DynList<T, StaticSize>::DynList
 (
     const label s,
     const T& val
@@ -185,8 +185,8 @@ inline Foam::Module::DynList<T, staticSize>::DynList
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::Module::DynList<T, staticSize>::DynList(const UList<T>& ul)
+template<class T, int StaticSize>
+inline Foam::Module::DynList<T, StaticSize>::DynList(const UList<T>& ul)
 :
     dataPtr_(nullptr),
     nAllocated_(0),
@@ -206,9 +206,9 @@ inline Foam::Module::DynList<T, staticSize>::DynList(const UList<T>& ul)
 }
 
 
-template<class T, Foam::label staticSize>
+template<class T, int StaticSize>
 template<class ListType>
-inline Foam::Module::DynList<T, staticSize>::DynList(const ListType& l)
+inline Foam::Module::DynList<T, StaticSize>::DynList(const ListType& l)
 :
     dataPtr_(nullptr),
     nAllocated_(0),
@@ -227,10 +227,10 @@ inline Foam::Module::DynList<T, staticSize>::DynList(const ListType& l)
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::Module::DynList<T, staticSize>::DynList
+template<class T, int StaticSize>
+inline Foam::Module::DynList<T, StaticSize>::DynList
 (
-    const DynList<T, staticSize>& dl
+    const DynList<T, StaticSize>& dl
 )
 :
     dataPtr_(nullptr),
@@ -250,8 +250,8 @@ inline Foam::Module::DynList<T, staticSize>::DynList
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::Module::DynList<T, staticSize>::~DynList()
+template<class T, int StaticSize>
+inline Foam::Module::DynList<T, StaticSize>::~DynList()
 {
     allocateSize(0);
 }
@@ -259,8 +259,8 @@ inline Foam::Module::DynList<T, staticSize>::~DynList()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-template<class T, Foam::label staticSize>
-inline Foam::label Foam::Module::DynList<T, staticSize>::size() const
+template<class T, int StaticSize>
+inline Foam::label Foam::Module::DynList<T, StaticSize>::size() const
 {
     # ifdef DEBUG
     checkAllocation();
@@ -270,8 +270,8 @@ inline Foam::label Foam::Module::DynList<T, staticSize>::size() const
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::label Foam::Module::DynList<T, staticSize>::byteSize() const
+template<class T, int StaticSize>
+inline Foam::label Foam::Module::DynList<T, StaticSize>::byteSize() const
 {
     # ifdef DEBUG
     checkAllocation();
@@ -289,8 +289,8 @@ inline Foam::label Foam::Module::DynList<T, staticSize>::byteSize() const
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::setSize(const label s)
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::setSize(const label s)
 {
     # ifdef DEBUG
     checkAllocation();
@@ -305,8 +305,8 @@ inline void Foam::Module::DynList<T, staticSize>::setSize(const label s)
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::clear()
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::clear()
 {
     # ifdef DEBUG
     checkAllocation();
@@ -316,8 +316,8 @@ inline void Foam::Module::DynList<T, staticSize>::clear()
 }
 
 
-template<class T, Foam::label staticSize>
-void Foam::Module::DynList<T, staticSize>::shrink()
+template<class T, int StaticSize>
+void Foam::Module::DynList<T, StaticSize>::shrink()
 {
     # ifdef DEBUG
     checkAllocation();
@@ -331,8 +331,8 @@ void Foam::Module::DynList<T, staticSize>::shrink()
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::append(const T& e)
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::append(const T& e)
 {
     # ifdef DEBUG
     checkAllocation();
@@ -352,8 +352,8 @@ inline void Foam::Module::DynList<T, staticSize>::append(const T& e)
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::appendIfNotIn(const T& e)
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::appendIfNotIn(const T& e)
 {
     # ifdef DEBUG
     checkAllocation();
@@ -370,8 +370,8 @@ inline void Foam::Module::DynList<T, staticSize>::appendIfNotIn(const T& e)
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::label Foam::Module::DynList<T, staticSize>::find
+template<class T, int StaticSize>
+inline Foam::label Foam::Module::DynList<T, StaticSize>::find
 (
     const T& e
 ) const
@@ -392,16 +392,16 @@ inline Foam::label Foam::Module::DynList<T, staticSize>::find
 }
 
 
-template<class T, Foam::label staticSize>
-inline bool Foam::Module::DynList<T, staticSize>::found(const T& e) const
+template<class T, int StaticSize>
+inline bool Foam::Module::DynList<T, StaticSize>::found(const T& e) const
 {
     return this->find(e) != -1;
 }
 
 
 
-template<class T, Foam::label staticSize>
-inline const T& Foam::Module::DynList<T, staticSize>::first() const
+template<class T, int StaticSize>
+inline const T& Foam::Module::DynList<T, StaticSize>::first() const
 {
     # ifdef DEBUG
     checkAllocation();
@@ -411,8 +411,8 @@ inline const T& Foam::Module::DynList<T, staticSize>::first() const
 }
 
 
-template<class T, Foam::label staticSize>
-inline const T& Foam::Module::DynList<T, staticSize>::last() const
+template<class T, int StaticSize>
+inline const T& Foam::Module::DynList<T, StaticSize>::last() const
 {
     # ifdef DEBUG
     checkAllocation();
@@ -422,8 +422,8 @@ inline const T& Foam::Module::DynList<T, staticSize>::last() const
 }
 
 
-template<class T, Foam::label staticSize>
-inline T Foam::Module::DynList<T, staticSize>::remove()
+template<class T, int StaticSize>
+inline T Foam::Module::DynList<T, StaticSize>::remove()
 {
     # ifdef DEBUG
     checkAllocation();
@@ -441,8 +441,8 @@ inline T Foam::Module::DynList<T, staticSize>::remove()
 }
 
 
-template<class T, Foam::label staticSize>
-inline T Foam::Module::DynList<T, staticSize>::removeElement(const label i)
+template<class T, int StaticSize>
+inline T Foam::Module::DynList<T, StaticSize>::removeElement(const label i)
 {
     # ifdef DEBUG
     checkAllocation();
@@ -466,8 +466,8 @@ inline T Foam::Module::DynList<T, staticSize>::removeElement(const label i)
 }
 
 
-template<class T, Foam::label staticSize>
-inline T& Foam::Module::DynList<T, staticSize>::newElmt(const label i)
+template<class T, int StaticSize>
+inline T& Foam::Module::DynList<T, StaticSize>::newElmt(const label i)
 {
     # ifdef DEBUG
     checkAllocation();
@@ -479,8 +479,8 @@ inline T& Foam::Module::DynList<T, staticSize>::newElmt(const label i)
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-template<class T, Foam::label staticSize>
-inline T& Foam::Module::DynList<T, staticSize>::operator()(const label i)
+template<class T, int StaticSize>
+inline T& Foam::Module::DynList<T, StaticSize>::operator()(const label i)
 {
     # ifdef DEBUG
     checkAllocation();
@@ -501,8 +501,8 @@ inline T& Foam::Module::DynList<T, staticSize>::operator()(const label i)
 }
 
 
-template<class T, Foam::label staticSize>
-inline const T& Foam::Module::DynList<T, staticSize>::operator[]
+template<class T, int StaticSize>
+inline const T& Foam::Module::DynList<T, StaticSize>::operator[]
 (
     const label i
 ) const
@@ -516,8 +516,8 @@ inline const T& Foam::Module::DynList<T, staticSize>::operator[]
 }
 
 
-template<class T, Foam::label staticSize>
-inline T& Foam::Module::DynList<T, staticSize>::operator[](const label i)
+template<class T, int StaticSize>
+inline T& Foam::Module::DynList<T, StaticSize>::operator[](const label i)
 {
     # ifdef FULLDEBUG
     checkAllocation();
@@ -528,8 +528,8 @@ inline T& Foam::Module::DynList<T, staticSize>::operator[](const label i)
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::label Foam::Module::DynList<T, staticSize>::fcIndex
+template<class T, int StaticSize>
+inline Foam::label Foam::Module::DynList<T, StaticSize>::fcIndex
 (
     const label index
 ) const
@@ -538,8 +538,8 @@ inline Foam::label Foam::Module::DynList<T, staticSize>::fcIndex
 }
 
 
-template<class T, Foam::label staticSize>
-inline Foam::label Foam::Module::DynList<T, staticSize>::rcIndex
+template<class T, int StaticSize>
+inline Foam::label Foam::Module::DynList<T, StaticSize>::rcIndex
 (
     const label index
 ) const
@@ -548,8 +548,8 @@ inline Foam::label Foam::Module::DynList<T, staticSize>::rcIndex
 }
 
 
-template<class T, Foam::label staticSize>
-inline const T& Foam::Module::DynList<T, staticSize>::fcValue
+template<class T, int StaticSize>
+inline const T& Foam::Module::DynList<T, StaticSize>::fcValue
 (
     const label index
 ) const
@@ -558,8 +558,8 @@ inline const T& Foam::Module::DynList<T, staticSize>::fcValue
 }
 
 
-template<class T, Foam::label staticSize>
-inline const T& Foam::Module::DynList<T, staticSize>::rcValue
+template<class T, int StaticSize>
+inline const T& Foam::Module::DynList<T, StaticSize>::rcValue
 (
     const label index
 ) const
@@ -568,8 +568,8 @@ inline const T& Foam::Module::DynList<T, staticSize>::rcValue
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::operator=(const T& t)
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::operator=(const T& t)
 {
     # ifdef DEBUG
     checkAllocation();
@@ -582,10 +582,10 @@ inline void Foam::Module::DynList<T, staticSize>::operator=(const T& t)
 }
 
 
-template<class T, Foam::label staticSize>
-inline void Foam::Module::DynList<T, staticSize>::operator=
+template<class T, int StaticSize>
+inline void Foam::Module::DynList<T, StaticSize>::operator=
 (
-    const DynList<T, staticSize>& dl
+    const DynList<T, StaticSize>& dl
 )
 {
     # ifdef DEBUG
@@ -606,10 +606,10 @@ inline void Foam::Module::DynList<T, staticSize>::operator=
 }
 
 
-template<class T, Foam::label staticSize>
-inline bool Foam::Module::DynList<T, staticSize>::operator==
+template<class T, int StaticSize>
+inline bool Foam::Module::DynList<T, StaticSize>::operator==
 (
-    const DynList<T, staticSize>& DL
+    const DynList<T, StaticSize>& DL
 ) const
 {
     if (nextFree_ != DL.nextFree_)
@@ -629,10 +629,10 @@ inline bool Foam::Module::DynList<T, staticSize>::operator==
 }
 
 
-template<class T, Foam::label staticSize>
-inline bool Foam::Module::DynList<T, staticSize>::operator!=
+template<class T, int StaticSize>
+inline bool Foam::Module::DynList<T, StaticSize>::operator!=
 (
-    const DynList<T, staticSize>& DL
+    const DynList<T, StaticSize>& DL
 ) const
 {
     return !operator==(DL);

meshLibrary/utilities/containers/FRWGraph/FRWGraph.H

@@ -140,7 +140,6 @@ public:
         inline void setRow(const label rowI, const FixedList<T, width>& l);
 
         //- check if the element is in the given row (takes linear time)
-        inline bool contains(const label rowI, const T& e) const;
         inline bool found(const label rowI, const T& e) const;
         inline label find(const label rowI, const T& e) const;
 

meshLibrary/utilities/containers/FRWGraph/FRWGraphI.H

@@ -155,17 +155,6 @@ inline void Foam::Module::FRWGraph<T, width>::setRow
 }
 
 
-template<class T, Foam::label width>
-inline bool Foam::Module::FRWGraph<T, width>::contains
-(
-    const label rowI,
-    const T& e
-) const
-{
-    return (this->find(rowI, e) >= 0);
-}
-
-
 template<class T, Foam::label width>
 inline bool Foam::Module::FRWGraph<T, width>::found
 (

meshLibrary/utilities/containers/LongList/LongList.H

@@ -178,7 +178,6 @@ public:
         inline void appendIfNotIn(const T& e);
 
         //- check if the element is in the list (takes linear time)
-        inline bool contains(const T& e) const;
         inline bool found(const T& e) const;
         inline label find(const T& e) const;
 

meshLibrary/utilities/containers/LongList/LongListI.H

@@ -296,13 +296,6 @@ inline void Foam::Module::LongList<T, Offset>::appendIfNotIn(const T& e)
 }
 
 
-template<class T, int Offset>
-inline bool Foam::Module::LongList<T, Offset>::contains(const T& e) const
-{
-    return (this->find(e) >= 0);
-}
-
-
 template<class T, int Offset>
 inline bool Foam::Module::LongList<T, Offset>::found(const T& e) const
 {

meshLibrary/utilities/containers/VRWGraph/VRWGraph.H

@@ -261,7 +261,6 @@ public:
         void optimizeMemoryUsage();
 
         //- check if the element is in the given row (takes linear time)
-        inline bool contains(const label rowI, const label e) const;
         inline bool found(const label rowI, const label e) const;
         inline label find(const label rowI, const label e) const;
 

meshLibrary/utilities/containers/VRWGraph/VRWGraphI.H

@@ -574,16 +574,6 @@ inline void Foam::Module::VRWGraph::reverseAddressing
 }
 
 
-inline bool Foam::Module::VRWGraph::contains
-(
-    const label rowI,
-    const label e
-) const
-{
-    return (this->find(rowI, e) >= 0);
-}
-
-
 inline bool Foam::Module::VRWGraph::found
 (
     const label rowI,

meshLibrary/utilities/containers/graphRow/graphConstRow.H

@@ -101,7 +101,6 @@ public:
     // Member Operators
 
         //- check if the element is in the given row (takes linear time)
-        inline bool contains(const label e) const;
         inline bool found(const label e) const;
         inline label find(const label e) const;
 

meshLibrary/utilities/containers/graphRow/graphConstRowI.H

@@ -70,16 +70,6 @@ inline Foam::label Foam::Module::graphConstRow<graphType>::size() const
 }
 
 
-template<class graphType>
-inline bool Foam::Module::graphConstRow<graphType>::contains
-(
-    const label e
-) const
-{
-    return data_.contains(rowI_, e);
-}
-
-
 template<class graphType>
 inline bool Foam::Module::graphConstRow<graphType>::found(const label e) const
 {

meshLibrary/utilities/containers/graphRow/graphRow.H

@@ -105,7 +105,6 @@ public:
         inline void appendIfNotIn(const label);
 
         //- check if the element is in the given row (takes linear time)
-        inline bool contains(const label e) const;
         inline bool found(const label e) const;
         inline label find(const label e) const;
 

meshLibrary/utilities/containers/graphRow/graphRowI.H

@@ -83,13 +83,6 @@ inline void Foam::Module::graphRow<graphType>::appendIfNotIn(const label el)
 }
 
 
-template<class graphType>
-inline bool Foam::Module::graphRow<graphType>::contains(const label e) const
-{
-    return data_.contains(rowI_, e);
-}
-
-
 template<class graphType>
 inline bool Foam::Module::graphRow<graphType>::found(const label e) const
 {

meshLibrary/utilities/containers/subGraph/subGraph.H

@@ -112,7 +112,6 @@ public:
         inline void appendIfNotIn(const label rowI, const label);
 
         //- check if the element is in the given row (takes linear time)
-        inline bool contains(const label rowI, const label e) const;
         inline bool found(const label rowI, const label e) const;
         inline label find(const label rowI, const label e) const;
 

meshLibrary/utilities/containers/subGraph/subGraphI.H

@@ -105,17 +105,6 @@ inline void Foam::Module::subGraph<graphType>::appendIfNotIn
 }
 
 
-template<class graphType>
-inline bool Foam::Module::subGraph<graphType>::contains
-(
-    const label rowI,
-    const label e
-) const
-{
-    return data_.contains(start_ + rowI, e);
-}
-
-
 template<class graphType>
 inline bool Foam::Module::subGraph<graphType>::found
 (

meshLibrary/utilities/decomposeCells/decomposeCellsPyramids.C

@@ -248,7 +248,7 @@ void Foam::Module::decomposeCells::decomposeCellIntoPyramids(const label cellI)
             {
                 const edge e(f[eI], f[(eI + 1)%f.size()]);
 
-                const label pos = cEdges.contains(e);
+                const label pos = cEdges.find(e);
 
                 if (pos < 0)
                 {

meshLibrary/utilities/meshes/polyMeshGen/polyMeshGenCellsI.H

@@ -75,7 +75,7 @@ inline void Foam::Module::polyMeshGenCells::cellInSubsets
 
     forAllConstIters(cellSubsets_, it)
     {
-        if (it->second.contains(cellI))
+        if (it->second.found(cellI))
         {
             cellSubsets.append(it->first);
         }