Provide consistency in assignment operators

Always return void to avoid various bugs associated with automatic
type conversion.

Resolves request http://openfoam.org/mantisbt/view.php?id=1973

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedVertex/indexedVertex.H

@@ -258,7 +258,7 @@ public:
         //- Fix the vertex so that it can't be moved
         inline bool& fixed();
 
-        inline indexedVertex& operator=(const indexedVertex& rhs)
+        inline void operator=(const indexedVertex& rhs)
         {
             Vb::operator=(rhs);
 
@@ -268,8 +268,6 @@ public:
             this->alignment_ = rhs.alignment();
             this->targetCellSize_ = rhs.targetCellSize();
             this->vertexFixed_ = rhs.fixed();
-
-            return *this;
         }
 
         inline bool operator==(const indexedVertex& rhs) const

src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -286,8 +286,7 @@ Foam::Xfer<Foam::labelList> Foam::PackedBoolList::used() const
 
 // * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
 
-Foam::PackedBoolList&
+void Foam::PackedBoolList::operator=(const Foam::UList<bool>& lst)
-Foam::PackedBoolList::operator=(const Foam::UList<bool>& lst)
 {
     this->setSize(lst.size());
 
@@ -296,8 +295,6 @@ Foam::PackedBoolList::operator=(const Foam::UList<bool>& lst)
     {
         set(elemI, lst[elemI]);
     }
-
-    return *this;
 }
 
 

src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H

@@ -191,24 +191,24 @@ public:
     // Member Operators
 
             //- Assignment of all entries to the given value.
-            inline PackedBoolList& operator=(const bool val);
+            inline void operator=(const bool val);
 
             //- Assignment operator.
-            inline PackedBoolList& operator=(const PackedBoolList&);
+            inline void operator=(const PackedBoolList&);
 
             //- Assignment operator.
-            inline PackedBoolList& operator=(const PackedList<1>&);
+            inline void operator=(const PackedList<1>&);
 
             //- Assignment operator.
-            PackedBoolList& operator=(const Foam::UList<bool>&);
+            void operator=(const Foam::UList<bool>&);
 
             //- Assignment operator,
             //  using the labels as indices to indicate which bits are set
-            inline PackedBoolList& operator=(const labelUList& indices);
+            inline void operator=(const labelUList& indices);
 
             //- Assignment operator,
             //  using the labels as indices to indicate which bits are set
-            inline PackedBoolList& operator=(const UIndirectList<label>&);
+            inline void operator=(const UIndirectList<label>&);
 
             //- Complement operator
             inline PackedBoolList operator~() const;

src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H

@@ -126,47 +126,35 @@ inline Foam::Xfer<Foam::PackedBoolList> Foam::PackedBoolList::xfer()
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-inline Foam::PackedBoolList&
+inline void Foam::PackedBoolList::operator=(const bool val)
-Foam::PackedBoolList::operator=(const bool val)
 {
     PackedList<1>::operator=(val);
-    return *this;
 }
 
 
-inline Foam::PackedBoolList&
+inline void Foam::PackedBoolList::operator=(const PackedBoolList& lst)
-Foam::PackedBoolList::operator=(const PackedBoolList& lst)
 {
     PackedList<1>::operator=(lst);
-    return *this;
 }
 
 
-inline Foam::PackedBoolList&
+inline void Foam::PackedBoolList::operator=(const PackedList<1>& lst)
-Foam::PackedBoolList::operator=(const PackedList<1>& lst)
 {
     PackedList<1>::operator=(lst);
-    return *this;
 }
 
 
-inline Foam::PackedBoolList&
+inline void Foam::PackedBoolList::operator=(const labelUList& indices)
-Foam::PackedBoolList::operator=(const labelUList& indices)
 {
     clear();
     set(indices);
-
-    return *this;
 }
 
 
-inline Foam::PackedBoolList&
+inline void Foam::PackedBoolList::operator=(const UIndirectList<label>& indices)
-Foam::PackedBoolList::operator=(const UIndirectList<label>& indices)
 {
     clear();
     set(indices);
-
-    return *this;
 }
 
 

src/OpenFOAM/containers/Lists/PackedList/PackedList.C

@@ -513,18 +513,15 @@ void Foam::PackedList<nBits>::writeEntry
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<unsigned nBits>
-Foam::PackedList<nBits>&
+void Foam::PackedList<nBits>::operator=(const PackedList<nBits>& lst)
-Foam::PackedList<nBits>::operator=(const PackedList<nBits>& lst)
 {
     StorageList::operator=(lst);
     size_ = lst.size();
-    return *this;
 }
 
 
 template<unsigned nBits>
-Foam::PackedList<nBits>&
+void Foam::PackedList<nBits>::operator=(const labelUList& lst)
-Foam::PackedList<nBits>::operator=(const labelUList& lst)
 {
     setCapacity(lst.size());
     size_ = lst.size();
@@ -533,13 +530,11 @@ Foam::PackedList<nBits>::operator=(const labelUList& lst)
     {
         set(i, lst[i]);
     }
-    return *this;
 }
 
 
 template<unsigned nBits>
-Foam::PackedList<nBits>&
+void Foam::PackedList<nBits>::operator=(const UIndirectList<label>& lst)
-Foam::PackedList<nBits>::operator=(const UIndirectList<label>& lst)
 {
     setCapacity(lst.size());
     size_ = lst.size();
@@ -548,7 +543,6 @@ Foam::PackedList<nBits>::operator=(const UIndirectList<label>& lst)
     {
         set(i, lst[i]);
     }
-    return *this;
 }
 
 

src/OpenFOAM/containers/Lists/PackedList/PackedList.H

@@ -398,16 +398,16 @@ public:
             inline iteratorBase operator[](const label);
 
             //- Assignment of all entries to the given value. Takes linear time.
-            inline PackedList<nBits>& operator=(const unsigned int val);
+            inline void operator=(const unsigned int val);
 
             //- Assignment operator.
-            PackedList<nBits>& operator=(const PackedList<nBits>&);
+            void operator=(const PackedList<nBits>&);
 
             //- Assignment operator.
-            PackedList<nBits>& operator=(const labelUList&);
+            void operator=(const labelUList&);
 
             //- Assignment operator.
-            PackedList<nBits>& operator=(const UIndirectList<label>&);
+            void operator=(const UIndirectList<label>&);
 
 
     // Iterators and helpers
@@ -468,11 +468,11 @@ public:
 
                 //- Assign value, not position.
                 //  This allows packed[0] = packed[3] for assigning values
-                inline unsigned int operator=(const iteratorBase&);
+                inline void operator=(const iteratorBase&);
 
                 //- Assign value.
                 //  A non-existent entry will be auto-vivified.
-                inline unsigned int operator=(const unsigned int val);
+                inline void operator=(const unsigned int val);
 
                 //- Conversion operator
                 //  Never auto-vivify entries.
@@ -522,7 +522,7 @@ public:
 
                 //- Assign from iteratorBase, eg iter = packedlist[i]
                 //  An out-of-range iterator is assigned end()
-                inline iterator& operator=(const iteratorBase&);
+                inline void operator=(const iteratorBase&);
 
                 //- Return value
                 inline unsigned int operator*() const;
@@ -583,7 +583,7 @@ public:
 
                 //- Assign from iteratorBase or derived
                 //  eg, iter = packedlist[i] or even iter = list.begin()
-                inline const_iterator& operator=(const iteratorBase&);
+                inline void operator=(const iteratorBase&);
 
                 //- Return referenced value directly
                 inline unsigned int operator*() const;

src/OpenFOAM/containers/Lists/PackedList/PackedListI.H

@@ -356,18 +356,21 @@ inline bool Foam::PackedList<nBits>::iteratorBase::operator!=
 
 
 template<unsigned nBits>
-inline unsigned int
+inline void Foam::PackedList<nBits>::iteratorBase::operator=
-Foam::PackedList<nBits>::iteratorBase::operator=(const iteratorBase& iter)
+(
+    const iteratorBase& iter
+)
 {
     const unsigned int val = iter.get();
     this->set(val);
-    return val;
 }
 
 
 template<unsigned nBits>
-inline unsigned int
+inline void Foam::PackedList<nBits>::iteratorBase::operator=
-Foam::PackedList<nBits>::iteratorBase::operator=(const unsigned int val)
+(
+    const unsigned int val
+)
 {
     // lazy evaluation - increase size on assigment
     if (index_ >= list_->size_)
@@ -376,7 +379,6 @@ Foam::PackedList<nBits>::iteratorBase::operator=(const unsigned int val)
     }
 
     this->set(val);
-    return val;
 }
 
 
@@ -517,8 +519,10 @@ inline bool Foam::PackedList<nBits>::const_iterator::operator!=
 
 
 template<unsigned nBits>
-inline typename Foam::PackedList<nBits>::iterator&
+inline void Foam::PackedList<nBits>::iterator::operator=
-Foam::PackedList<nBits>::iterator::operator=(const iteratorBase& iter)
+(
+    const iteratorBase& iter
+)
 {
     this->list_  = iter.list_;
     this->index_ = iter.index_;
@@ -529,14 +533,14 @@ Foam::PackedList<nBits>::iterator::operator=(const iteratorBase& iter)
     {
         this->index_ = this->list_->size_;
     }
-
-    return *this;
 }
 
 
 template<unsigned nBits>
-inline typename Foam::PackedList<nBits>::const_iterator&
+inline void Foam::PackedList<nBits>::const_iterator::operator=
-Foam::PackedList<nBits>::const_iterator::operator=(const iteratorBase& iter)
+(
+    const iteratorBase& iter
+)
 {
     this->list_  = iter.list_;
     this->index_ = iter.index_;
@@ -1066,8 +1070,7 @@ Foam::PackedList<nBits>::operator[](const label i)
 
 
 template<unsigned nBits>
-inline Foam::PackedList<nBits>&
+inline void Foam::PackedList<nBits>::operator=(const unsigned int val)
-Foam::PackedList<nBits>::operator=(const unsigned int val)
 {
     const label packLen = packedLength();
 
@@ -1111,8 +1114,6 @@ Foam::PackedList<nBits>::operator=(const unsigned int val)
             StorageList::operator[](i) = 0u;
         }
     }
-
-    return *this;
 }
 
 

src/OpenFOAM/containers/Lists/PtrList/PtrList.C

@@ -258,7 +258,7 @@ void Foam::PtrList<T>::reorder(const labelUList& oldToNew)
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class T>
-Foam::PtrList<T>& Foam::PtrList<T>::operator=(const PtrList<T>& a)
+void Foam::PtrList<T>::operator=(const PtrList<T>& a)
 {
     if (this == &a)
     {
@@ -290,9 +290,6 @@ Foam::PtrList<T>& Foam::PtrList<T>::operator=(const PtrList<T>& a)
             << " for type " << typeid(T).name()
             << abort(FatalError);
     }
-
-
-    return *this;
 }
 
 

src/OpenFOAM/containers/Lists/PtrList/PtrList.H

@@ -252,9 +252,8 @@ public:
         //- Return element const pointer.
         inline const T* operator()(const label) const;
 
-
         //- Assignment.
-        PtrList<T>& operator=(const PtrList<T>&);
+        void operator=(const PtrList<T>&);
 
 
     // STL type definitions

src/OpenFOAM/primitives/bools/Switch/Switch.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -188,17 +188,15 @@ public:
         }
 
         //- Assignment from enumerated value
-        const Switch& operator=(const switchType sw)
+        void operator=(const switchType sw)
         {
             switch_ = sw;
-            return *this;
         }
 
         //- Assignment from bool
-        const Switch& operator=(const bool b)
+        void operator=(const bool b)
         {
             switch_ = (b ? Switch::TRUE : Switch::FALSE);
-            return *this;
         }
 
 

src/OpenFOAM/primitives/complex/complex.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -126,13 +126,13 @@ public:
 
     // Member operators
 
-        inline const complex& operator=(const complex&);
+        inline void operator=(const complex&);
         inline void operator+=(const complex&);
         inline void operator-=(const complex&);
         inline void operator*=(const complex&);
         inline void operator/=(const complex&);
 
-        inline const complex& operator=(const scalar);
+        inline void operator=(const scalar);
         inline void operator+=(const scalar);
         inline void operator-=(const scalar);
         inline void operator*=(const scalar);

src/OpenFOAM/primitives/complex/complexI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -75,11 +75,10 @@ inline complex complex::conjugate() const
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-inline const complex& complex::operator=(const complex& c)
+inline void complex::operator=(const complex& c)
 {
     re = c.re;
     im = c.im;
-    return *this;
 }
 
 
@@ -109,11 +108,10 @@ inline void complex::operator/=(const complex& c)
 }
 
 
-inline const complex& complex::operator=(const scalar s)
+inline void complex::operator=(const scalar s)
 {
     re = s;
     im = 0.0;
-    return *this;
 }
 
 

src/OpenFOAM/primitives/nullObject/nullObject.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -51,11 +51,11 @@ class NullObject
     NullObject()
     {}
 
-    //- Prevent copy-construction
+    //- Disallow default bitwise copy construct
     NullObject(const NullObject&);
 
-    //- Prevent assignment
+    //- Disallow default bitwise assignment
-    NullObject& operator=(const NullObject&);
+    void operator=(const NullObject&);
 
 public:
 

src/OpenFOAM/primitives/strings/fileName/fileName.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,7 +26,6 @@ License
 #include "fileName.H"
 #include "wordList.H"
 #include "DynamicList.H"
-#include "debug.H"
 #include "OSspecific.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -35,6 +34,7 @@ const char* const Foam::fileName::typeName = "fileName";
 int Foam::fileName::debug(debug::debugSwitch(fileName::typeName, 0));
 const Foam::fileName Foam::fileName::null;
 
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fileName::fileName(const wordList& lst)
@@ -74,32 +74,18 @@ Foam::fileName& Foam::fileName::toAbsolute()
 }
 
 
-//
-// * remove repeated slashes
-//       /abc////def        -->   /abc/def
-//
-// * remove '/./'
-//       /abc/def/./ghi/.   -->   /abc/def/./ghi
-//       abc/def/./         -->   abc/def
-//
-// * remove '/../'
-//       /abc/def/../ghi/jkl/nmo/..   -->   /abc/ghi/jkl
-//       abc/../def/ghi/../jkl        -->   abc/../def/jkl
-//
-// * remove trailing '/'
-//
 bool Foam::fileName::clean()
 {
-    // the top slash - we are never allowed to go above it
+    // The top slash - we are never allowed to go above it
     string::size_type top = this->find('/');
 
-    // no slashes - nothing to do
+    // No slashes - nothing to do
     if (top == string::npos)
     {
         return false;
     }
 
-    // start with the '/' found:
+    // Start with the '/' found:
     char prev = '/';
     string::size_type nChar  = top+1;
     string::size_type maxLen = this->size();
@@ -108,47 +94,46 @@ bool Foam::fileName::clean()
     (
         string::size_type src = nChar;
         src < maxLen;
-        /*nil*/
     )
     {
         char c = operator[](src++);
 
         if (prev == '/')
         {
-            // repeated '/' - skip it
+            // Repeated '/' - skip it
             if (c == '/')
             {
                 continue;
             }
 
-            // could be '/./' or '/../'
+            // Could be '/./' or '/../'
             if (c == '.')
             {
-                // found trailing '/.' - skip it
+                // Found trailing '/.' - skip it
                 if (src >= maxLen)
                 {
                     continue;
                 }
 
 
-                // peek at the next character
+                // Peek at the next character
                 char c1 = operator[](src);
 
-                // found '/./' - skip it
+                // Found '/./' - skip it
                 if (c1 == '/')
                 {
                     src++;
                     continue;
                 }
 
-                // it is '/..' or '/../'
+                // It is '/..' or '/../'
                 if (c1 == '.' && (src+1 >= maxLen || operator[](src+1) == '/'))
                 {
                     string::size_type parent;
 
-                    // backtrack to find the parent directory
+                    // Backtrack to find the parent directory
-                    // minimum of 3 characters:  '/x/../'
+                    // Minimum of 3 characters:  '/x/../'
-                    // strip it, provided it is above the top point
+                    // Strip it, provided it is above the top point
                     if
                     (
                         nChar > 2
@@ -156,13 +141,13 @@ bool Foam::fileName::clean()
                      && parent >= top
                     )
                     {
-                        nChar = parent + 1;   // retain '/' from the parent
+                        nChar = parent + 1;   // Retain '/' from the parent
                         src += 2;
                         continue;
                     }
 
-                    // bad resolution, eg 'abc/../../'
+                    // Bad resolution, eg 'abc/../../'
-                    // retain the sequence, but move the top to avoid it being
+                    // Retain the sequence, but move the top to avoid it being
                     // considered a valid parent later
                     top = nChar + 2;
                 }
@@ -171,7 +156,7 @@ bool Foam::fileName::clean()
         operator[](nChar++) = prev = c;
     }
 
-    // remove trailing slash
+    // Remove trailing slash
     if (nChar > 1 && operator[](nChar-1) == '/')
     {
         nChar--;
@@ -191,18 +176,6 @@ Foam::fileName Foam::fileName::clean() const
 }
 
 
-
-//  Return file name (part beyond last /)
-//
-//  behaviour compared to /usr/bin/basename:
-//    input           name()          basename
-//    -----           ------          --------
-//    "foo"           "foo"           "foo"
-//    "/foo"          "foo"           "foo"
-//    "foo/bar"       "bar"           "bar"
-//    "/foo/bar"      "bar"           "bar"
-//    "/foo/bar/"     ""              "bar"
-//
 Foam::word Foam::fileName::name() const
 {
     size_type i = rfind('/');
@@ -273,17 +246,6 @@ Foam::word Foam::fileName::name(const bool noExt) const
 }
 
 
-//  Return directory path name (part before last /)
-//
-//  behaviour compared to /usr/bin/dirname:
-//    input           path()          dirname
-//    -----           ------          -------
-//    "foo"           "."             "."
-//    "/foo"          "/"             "foo"
-//    "foo/bar"       "foo"           "foo"
-//    "/foo/bar"      "/foo"          "/foo"
-//    "/foo/bar/"     "/foo/bar/"     "/foo"
-//
 Foam::fileName Foam::fileName::path() const
 {
     size_type i = rfind('/');
@@ -303,7 +265,6 @@ Foam::fileName Foam::fileName::path() const
 }
 
 
-//  Return file name without extension (part before last .)
 Foam::fileName Foam::fileName::lessExt() const
 {
     size_type i = find_last_of("./");
@@ -319,7 +280,6 @@ Foam::fileName Foam::fileName::lessExt() const
 }
 
 
-//  Return file name extension (part after last .)
 Foam::word Foam::fileName::ext() const
 {
     size_type i = find_last_of("./");
@@ -335,19 +295,6 @@ Foam::word Foam::fileName::ext() const
 }
 
 
-// Return the components of the file name as a wordList
-// note that concatenating the components will not necessarily retrieve
-// the original input fileName
-//
-//  behaviour
-//    input           components()
-//    -----           ------
-//    "foo"           1("foo")
-//    "/foo"          1("foo")
-//    "foo/bar"       2("foo", "bar")
-//    "/foo/bar"      2("foo", "bar")
-//    "/foo/bar/"     2("foo", "bar")
-//
 Foam::wordList Foam::fileName::components(const char delimiter) const
 {
     DynamicList<word> wrdList(20);
@@ -356,7 +303,7 @@ Foam::wordList Foam::fileName::components(const char delimiter) const
 
     while ((end = find(delimiter, beg)) != npos)
     {
-        // avoid empty element (caused by doubled slashes)
+        // Avoid empty element (caused by doubled slashes)
         if (beg < end)
         {
             wrdList.append(substr(beg, end-beg));
@@ -364,18 +311,17 @@ Foam::wordList Foam::fileName::components(const char delimiter) const
         beg = end + 1;
     }
 
-    // avoid empty trailing element
+    // Avoid empty trailing element
     if (beg < size())
     {
         wrdList.append(substr(beg, npos));
     }
 
-    // transfer to wordList
+    // Transfer to wordList
     return wordList(wrdList.xfer());
 }
 
 
-// Return a component of the file name
 Foam::word Foam::fileName::component
 (
     const size_type cmpt,
@@ -388,41 +334,36 @@ Foam::word Foam::fileName::component
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-const Foam::fileName& Foam::fileName::operator=(const fileName& str)
+void Foam::fileName::operator=(const fileName& str)
 {
     string::operator=(str);
-    return *this;
 }
 
 
-const Foam::fileName& Foam::fileName::operator=(const word& str)
+void Foam::fileName::operator=(const word& str)
 {
     string::operator=(str);
-    return *this;
 }
 
 
-const Foam::fileName& Foam::fileName::operator=(const string& str)
+void Foam::fileName::operator=(const string& str)
 {
     string::operator=(str);
     stripInvalid();
-    return *this;
 }
 
 
-const Foam::fileName& Foam::fileName::operator=(const std::string& str)
+void Foam::fileName::operator=(const std::string& str)
 {
     string::operator=(str);
     stripInvalid();
-    return *this;
 }
 
 
-const Foam::fileName& Foam::fileName::operator=(const char* str)
+void Foam::fileName::operator=(const char* str)
 {
     string::operator=(str);
     stripInvalid();
-    return *this;
 }
 
 

src/OpenFOAM/primitives/strings/fileName/fileName.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -131,7 +131,20 @@ public:
         inline static bool valid(char);
 
         //- Cleanup file name
-        //  eg, remove repeated slashes, etc.
+        //
+        // * Removes repeated slashes
+        //       /abc////def        -->   /abc/def
+        //
+        // * Removes '/./'
+        //       /abc/def/./ghi/.   -->   /abc/def/./ghi
+        //       abc/def/./         -->   abc/def
+        //
+        // * Removes '/../'
+        //       /abc/def/../ghi/jkl/nmo/..   -->   /abc/ghi/jkl
+        //       abc/../def/ghi/../jkl        -->   abc/../def/jkl
+        //
+        // * Removes trailing '/'
+        //
         bool clean();
 
         //- Cleanup file name
@@ -154,6 +167,16 @@ public:
         // Decomposition
 
             //- Return file name (part beyond last /)
+            //
+            //  Behaviour compared to /usr/bin/basename:
+            //    Input           name()          basename
+            //    -----           ------          --------
+            //    "foo"           "foo"           "foo"
+            //    "/foo"          "foo"           "foo"
+            //    "foo/bar"       "bar"           "bar"
+            //    "/foo/bar"      "bar"           "bar"
+            //    "/foo/bar/"     ""              "bar"
+            //
             word name() const;
 
             //- Return file name (part beyond last /), subsitute for FOAM_CASE
@@ -163,6 +186,16 @@ public:
             word name(const bool noExt) const;
 
             //- Return directory path name (part before last /)
+            //
+            //  Behaviour compared to /usr/bin/dirname:
+            //    input           path()          dirname
+            //    -----           ------          -------
+            //    "foo"           "."             "."
+            //    "/foo"          "/"             "foo"
+            //    "foo/bar"       "foo"           "foo"
+            //    "/foo/bar"      "/foo"          "/foo"
+            //    "/foo/bar/"     "/foo/bar/"     "/foo"
+            //
             fileName path() const;
 
             //- Return file name without extension (part before last .)
@@ -172,6 +205,15 @@ public:
             word ext() const;
 
             //- Return path components as wordList
+            //
+            //  Behaviour:
+            //    Input           components()
+            //    -----           ------
+            //    "foo"           1("foo")
+            //    "/foo"          1("foo")
+            //    "foo/bar"       2("foo", "bar")
+            //    "/foo/bar"      2("foo", "bar")
+            //    "/foo/bar/"     2("foo", "bar")
             wordList components(const char delimiter='/') const;
 
             //- Return a single component of the path
@@ -182,11 +224,11 @@ public:
 
         // Assignment
 
-            const fileName& operator=(const fileName&);
+            void operator=(const fileName&);
-            const fileName& operator=(const word&);
+            void operator=(const word&);
-            const fileName& operator=(const string&);
+            void operator=(const string&);
-            const fileName& operator=(const std::string&);
+            void operator=(const std::string&);
-            const fileName& operator=(const char*);
+            void operator=(const char*);
 
 
     // IOstream operators

src/OpenFOAM/primitives/strings/keyType/keyType.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -116,16 +116,16 @@ public:
         // Assignment
 
             //- Assignment operator
-            inline const keyType& operator=(const keyType&);
+            inline void operator=(const keyType&);
 
             //- Assign as word, not as non regular expression
-            inline const keyType& operator=(const word&);
+            inline void operator=(const word&);
 
             //- Assign as regular expression
-            inline const keyType& operator=(const string&);
+            inline void operator=(const string&);
 
             //- Assign as word, not as non regular expression
-            inline const keyType& operator=(const char*);
+            inline void operator=(const char*);
 
 
     // IOstream operators

src/OpenFOAM/primitives/strings/keyType/keyTypeI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -81,38 +81,34 @@ inline bool Foam::keyType::isPattern() const
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-inline const Foam::keyType& Foam::keyType::operator=(const keyType& s)
+inline void Foam::keyType::operator=(const keyType& s)
 {
     // Bypass checking
     string::operator=(s);
     isPattern_ = s.isPattern_;
-    return *this;
 }
 
 
-inline const Foam::keyType& Foam::keyType::operator=(const word& s)
+inline void Foam::keyType::operator=(const word& s)
 {
     word::operator=(s);
     isPattern_ = false;
-    return *this;
 }
 
 
-inline const Foam::keyType& Foam::keyType::operator=(const string& s)
+inline void Foam::keyType::operator=(const string& s)
 {
     // Bypass checking
     string::operator=(s);
     isPattern_ = true;
-    return *this;
 }
 
 
-inline const Foam::keyType& Foam::keyType::operator=(const char* s)
+inline void Foam::keyType::operator=(const char* s)
 {
     // Bypass checking
     string::operator=(s);
     isPattern_ = false;
-    return *this;
 }
 
 

src/OpenFOAM/primitives/strings/word/word.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -117,10 +117,10 @@ public:
 
         // Assignment
 
-            inline const word& operator=(const word&);
+            inline void operator=(const word&);
-            inline const word& operator=(const string&);
+            inline void operator=(const string&);
-            inline const word& operator=(const std::string&);
+            inline void operator=(const std::string&);
-            inline const word& operator=(const char*);
+            inline void operator=(const char*);
 
 
     // Friend Operators

src/OpenFOAM/primitives/strings/word/wordI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -131,34 +131,30 @@ inline bool Foam::word::valid(char c)
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-inline const Foam::word& Foam::word::operator=(const word& q)
+inline void Foam::word::operator=(const word& q)
 {
     string::operator=(q);
-    return *this;
 }
 
 
-inline const Foam::word& Foam::word::operator=(const string& q)
+inline void Foam::word::operator=(const string& q)
 {
     string::operator=(q);
     stripInvalid();
-    return *this;
 }
 
 
-inline const Foam::word& Foam::word::operator=(const std::string& q)
+inline void Foam::word::operator=(const std::string& q)
 {
     string::operator=(q);
     stripInvalid();
-    return *this;
 }
 
 
-inline const Foam::word& Foam::word::operator=(const char* q)
+inline void Foam::word::operator=(const char* q)
 {
     string::operator=(q);
     stripInvalid();
-    return *this;
 }
 
 

src/OpenFOAM/primitives/strings/wordRe/wordRe.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -207,26 +207,26 @@ public:
 
             //- Assign copy
             //  Always case sensitive
-            inline const wordRe& operator=(const wordRe&);
+            inline void operator=(const wordRe&);
 
             //- Copy word, never a regular expression
-            inline const wordRe& operator=(const word&);
+            inline void operator=(const word&);
 
             //- Copy keyType, auto-test for regular expression
             //  Always case sensitive
-            inline const wordRe& operator=(const keyType&);
+            inline void operator=(const keyType&);
 
             //- Copy string, auto-test for regular expression
             //  Always case sensitive
-            inline const wordRe& operator=(const string&);
+            inline void operator=(const string&);
 
             //- Copy string, auto-test for regular expression
             //  Always case sensitive
-            inline const wordRe& operator=(const std::string&);
+            inline void operator=(const std::string&);
 
             //- Copy string, auto-test for regular expression
             //  Always case sensitive
-            inline const wordRe& operator=(const char*);
+            inline void operator=(const char*);
 
 
     // IOstream operators

src/OpenFOAM/primitives/strings/wordRe/wordReI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -236,7 +236,7 @@ inline void Foam::wordRe::set(const char* str, const compOption opt)
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-inline const Foam::wordRe& Foam::wordRe::operator=(const wordRe& str)
+inline void Foam::wordRe::operator=(const wordRe& str)
 {
     string::operator=(str);
 
@@ -248,50 +248,44 @@ inline const Foam::wordRe& Foam::wordRe::operator=(const wordRe& str)
     {
         re_.clear();
     }
-    return *this;
 }
 
 
-inline const Foam::wordRe& Foam::wordRe::operator=(const word& str)
+inline void Foam::wordRe::operator=(const word& str)
 {
     word::operator=(str);
     re_.clear();
-    return *this;
 }
 
 
-inline const Foam::wordRe& Foam::wordRe::operator=(const keyType& str)
+inline void Foam::wordRe::operator=(const keyType& str)
 {
     string::operator=(str);
     if (str.isPattern())
     {
         compile();
     }
-    return *this;
 }
 
 
-inline const Foam::wordRe& Foam::wordRe::operator=(const string& str)
+inline void Foam::wordRe::operator=(const string& str)
 {
     string::operator=(str);
     compile(DETECT);  // auto-detect regex
-    return *this;
 }
 
 
-inline const Foam::wordRe& Foam::wordRe::operator=(const std::string& str)
+inline void Foam::wordRe::operator=(const std::string& str)
 {
     string::operator=(str);
     compile(DETECT);  // auto-detect regex
-    return *this;
 }
 
 
-inline const Foam::wordRe& Foam::wordRe::operator=(const char* str)
+inline void Foam::wordRe::operator=(const char* str)
 {
     string::operator=(str);
     compile(DETECT);  // auto-detect regex
-    return *this;
 }
 
 

src/TurbulenceModels/compressible/RAS/buoyantKEpsilon/buoyantKEpsilon.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -86,7 +86,7 @@ class buoyantKEpsilon
 
         // Disallow default bitwise copy construct and assignment
         buoyantKEpsilon(const buoyantKEpsilon&);
-        buoyantKEpsilon& operator=(const buoyantKEpsilon&);
+        void operator=(const buoyantKEpsilon&);
 
 
 protected:

src/TurbulenceModels/incompressible/turbulentTransportModels/RAS/LamBremhorstKE/LamBremhorstKE.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -70,7 +70,7 @@ class LamBremhorstKE
 
         // Disallow default bitwise copy construct and assignment
         LamBremhorstKE(const LamBremhorstKE&);
-        LamBremhorstKE& operator=(const LamBremhorstKE&);
+        void operator=(const LamBremhorstKE&);
 
         tmp<volScalarField> Rt() const;
         tmp<volScalarField> fMu(const volScalarField& Rt) const;

src/TurbulenceModels/phaseCompressible/LES/Niceno/NicenoKEqn.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -96,7 +96,7 @@ class NicenoKEqn
 
         // Disallow default bitwise copy construct and assignment
         NicenoKEqn(const NicenoKEqn&);
-        NicenoKEqn& operator=(const NicenoKEqn&);
+        void operator=(const NicenoKEqn&);
 
 
 protected:

src/TurbulenceModels/phaseCompressible/LES/SmagorinskyZhang/SmagorinskyZhang.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -94,7 +94,7 @@ class SmagorinskyZhang
 
         // Disallow default bitwise copy construct and assignment
         SmagorinskyZhang(const SmagorinskyZhang&);
-        SmagorinskyZhang& operator=(const SmagorinskyZhang&);
+        void operator=(const SmagorinskyZhang&);
 
 
 protected:

src/TurbulenceModels/phaseCompressible/LES/continuousGasKEqn/continuousGasKEqn.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -84,7 +84,7 @@ class continuousGasKEqn
 
         // Disallow default bitwise copy construct and assignment
         continuousGasKEqn(const continuousGasKEqn&);
-        continuousGasKEqn& operator=(const continuousGasKEqn&);
+        void operator=(const continuousGasKEqn&);
 
 
 protected:

src/TurbulenceModels/phaseCompressible/RAS/LaheyKEpsilon/LaheyKEpsilon.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -98,7 +98,7 @@ class LaheyKEpsilon
 
         // Disallow default bitwise copy construct and assignment
         LaheyKEpsilon(const LaheyKEpsilon&);
-        LaheyKEpsilon& operator=(const LaheyKEpsilon&);
+        void operator=(const LaheyKEpsilon&);
 
 
 protected:

src/TurbulenceModels/phaseCompressible/RAS/continuousGasKEpsilon/continuousGasKEpsilon.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -91,7 +91,7 @@ class continuousGasKEpsilon
 
         // Disallow default bitwise copy construct and assignment
         continuousGasKEpsilon(const continuousGasKEpsilon&);
-        continuousGasKEpsilon& operator=(const continuousGasKEpsilon&);
+        void operator=(const continuousGasKEpsilon&);
 
 
 protected:

src/TurbulenceModels/phaseCompressible/RAS/kOmegaSSTSato/kOmegaSSTSato.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -142,7 +142,7 @@ class kOmegaSSTSato
 
         // Disallow default bitwise copy construct and assignment
         kOmegaSSTSato(const kOmegaSSTSato&);
-        kOmegaSSTSato& operator=(const kOmegaSSTSato&);
+        void operator=(const kOmegaSSTSato&);
 
 
 protected:

src/TurbulenceModels/phaseCompressible/RAS/mixtureKEpsilon/mixtureKEpsilon.H

@@ -94,7 +94,7 @@ class mixtureKEpsilon
 
         // Disallow default bitwise copy construct and assignment
         mixtureKEpsilon(const mixtureKEpsilon&);
-        mixtureKEpsilon& operator=(const mixtureKEpsilon&);
+        void operator=(const mixtureKEpsilon&);
 
         //- Return the turbulence model for the other phase
         mixtureKEpsilon<BasicTurbulenceModel>& liquidTurbulence() const;

src/TurbulenceModels/turbulenceModels/LES/DeardorffDiffStress/DeardorffDiffStress.H

@@ -88,7 +88,7 @@ class DeardorffDiffStress
 
         // Disallow default bitwise copy construct and assignment
         DeardorffDiffStress(const DeardorffDiffStress&);
-        DeardorffDiffStress& operator=(const DeardorffDiffStress&);
+        void operator=(const DeardorffDiffStress&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/LESeddyViscosity/LESeddyViscosity.H

@@ -61,7 +61,7 @@ class LESeddyViscosity
 
         // Disallow default bitwise copy construct and assignment
         LESeddyViscosity(const LESeddyViscosity&);
-        LESeddyViscosity& operator=(const LESeddyViscosity&);
+        void operator=(const LESeddyViscosity&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/Smagorinsky/Smagorinsky.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -95,7 +95,7 @@ class Smagorinsky
 
         // Disallow default bitwise copy construct and assignment
         Smagorinsky(const Smagorinsky&);
-        Smagorinsky& operator=(const Smagorinsky&);
+        void operator=(const Smagorinsky&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/SpalartAllmarasDDES/SpalartAllmarasDDES.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -74,7 +74,7 @@ class SpalartAllmarasDDES
 
         // Disallow default bitwise copy construct and assignment
         SpalartAllmarasDDES(const SpalartAllmarasDDES&);
-        SpalartAllmarasDDES& operator=(const SpalartAllmarasDDES&);
+        void operator=(const SpalartAllmarasDDES&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/SpalartAllmarasDES/SpalartAllmarasDES.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -69,7 +69,7 @@ class SpalartAllmarasDES
 
         // Disallow default bitwise copy construct and assignment
         SpalartAllmarasDES(const SpalartAllmarasDES&);
-        SpalartAllmarasDES& operator=(const SpalartAllmarasDES&);
+        void operator=(const SpalartAllmarasDES&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/SpalartAllmarasIDDES/SpalartAllmarasIDDES.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -96,7 +96,7 @@ class SpalartAllmarasIDDES
 
         // Disallow default bitwise copy construct and assignment
         SpalartAllmarasIDDES(const SpalartAllmarasIDDES&);
-        SpalartAllmarasIDDES& operator=(const SpalartAllmarasIDDES&);
+        void operator=(const SpalartAllmarasIDDES&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/WALE/WALE.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2015-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -82,7 +82,7 @@ class WALE
 
         // Disallow default bitwise copy construct and assignment
         WALE(const WALE&);
-        WALE& operator=(const WALE&);
+        void operator=(const WALE&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/dynamicKEqn/dynamicKEqn.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -82,7 +82,7 @@ class dynamicKEqn
 
         // Disallow default bitwise copy construct and assignment
         dynamicKEqn(const dynamicKEqn&);
-        dynamicKEqn& operator=(const dynamicKEqn&);
+        void operator=(const dynamicKEqn&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/dynamicLagrangian/dynamicLagrangian.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -68,7 +68,7 @@ class dynamicLagrangian
 
         // Disallow default bitwise copy construct and assignment
         dynamicLagrangian(const dynamicLagrangian&);
-        dynamicLagrangian& operator=(const dynamicLagrangian&);
+        void operator=(const dynamicLagrangian&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/LES/kEqn/kEqn.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -80,7 +80,7 @@ class kEqn
 
         // Disallow default bitwise copy construct and assignment
         kEqn(const kEqn&);
-        kEqn& operator=(const kEqn&);
+        void operator=(const kEqn&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/LRR/LRR.H

@@ -106,7 +106,7 @@ class LRR
 
         // Disallow default bitwise copy construct and assignment
         LRR(const LRR&);
-        LRR& operator=(const LRR&);
+        void operator=(const LRR&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/LaunderSharmaKE/LaunderSharmaKE.H

@@ -90,7 +90,7 @@ class LaunderSharmaKE
 
         // Disallow default bitwise copy construct and assignment
         LaunderSharmaKE(const LaunderSharmaKE&);
-        LaunderSharmaKE& operator=(const LaunderSharmaKE&);
+        void operator=(const LaunderSharmaKE&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/RNGkEpsilon/RNGkEpsilon.H

@@ -91,7 +91,7 @@ class RNGkEpsilon
 
         // Disallow default bitwise copy construct and assignment
         RNGkEpsilon(const RNGkEpsilon&);
-        RNGkEpsilon& operator=(const RNGkEpsilon&);
+        void operator=(const RNGkEpsilon&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/SSG/SSG.H

@@ -101,7 +101,7 @@ class SSG
 
         // Disallow default bitwise copy construct and assignment
         SSG(const SSG&);
-        SSG& operator=(const SSG&);
+        void operator=(const SSG&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/SpalartAllmaras/SpalartAllmaras.H

@@ -94,7 +94,7 @@ class SpalartAllmaras
 
         // Disallow default bitwise copy construct and assignment
         SpalartAllmaras(const SpalartAllmaras&);
-        SpalartAllmaras& operator=(const SpalartAllmaras&);
+        void operator=(const SpalartAllmaras&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/kEpsilon/kEpsilon.H

@@ -92,7 +92,7 @@ class kEpsilon
 
         // Disallow default bitwise copy construct and assignment
         kEpsilon(const kEpsilon&);
-        kEpsilon& operator=(const kEpsilon&);
+        void operator=(const kEpsilon&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/kOmegaSST/kOmegaSST.H

@@ -126,7 +126,7 @@ class kOmegaSST
 
         // Disallow default bitwise copy construct and assignment
         kOmegaSST(const kOmegaSST&);
-        kOmegaSST& operator=(const kOmegaSST&);
+        void operator=(const kOmegaSST&);
 
 
 protected:

src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTSAS/kOmegaSSTSAS.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2015-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -104,7 +104,7 @@ class kOmegaSSTSAS
 
         // Disallow default bitwise copy construct and assignment
         kOmegaSSTSAS(const kOmegaSSTSAS&);
-        kOmegaSSTSAS& operator=(const kOmegaSSTSAS&);
+        void operator=(const kOmegaSSTSAS&);
 
 
 protected:

src/thermophysicalModels/solidSpecie/transport/const/constAnIsoSolidTransport.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -133,10 +133,7 @@ public:
 
     // Member operators
 
-        inline constAnIsoSolidTransport& operator=
+        inline void operator=(const constAnIsoSolidTransport&);
-        (
-            const constAnIsoSolidTransport&
-        );
         inline void operator+=(const constAnIsoSolidTransport&);
         inline void operator-=(const constAnIsoSolidTransport&);
 

src/thermophysicalModels/solidSpecie/transport/const/constAnIsoSolidTransportI.H

@@ -98,15 +98,12 @@ alphah(const scalar p, const scalar T) const
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Thermo>
-inline Foam::constAnIsoSolidTransport<Thermo>&
+inline void Foam::constAnIsoSolidTransport<Thermo>::operator=
-Foam::constAnIsoSolidTransport<Thermo>::operator=
 (
     const constAnIsoSolidTransport<Thermo>& ct
 )
 {
     kappa_ = ct.kappa_;
-
-    return *this;
 }
 
 

src/thermophysicalModels/solidSpecie/transport/const/constIsoSolidTransport.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -134,10 +134,7 @@ public:
 
     // Member operators
 
-        inline constIsoSolidTransport& operator=
+        inline void operator=(const constIsoSolidTransport&);
-        (
-            const constIsoSolidTransport&
-        );
         inline void operator+=(const constIsoSolidTransport&);
         inline void operator-=(const constIsoSolidTransport&);
 

src/thermophysicalModels/solidSpecie/transport/const/constIsoSolidTransportI.H

@@ -98,15 +98,13 @@ alphah(const scalar p, const scalar T) const
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class thermo>
-inline Foam::constIsoSolidTransport<thermo>&
+inline void Foam::constIsoSolidTransport<thermo>::operator=
-Foam::constIsoSolidTransport<thermo>::operator=
 (
     const constIsoSolidTransport<thermo>& ct
 )
 {
     thermo::operator=(ct);
     kappa_ = ct.kappa_;
-    return *this;
 }
 
 

src/thermophysicalModels/solidSpecie/transport/exponential/exponentialSolidTransport.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -142,10 +142,7 @@ public:
 
     // Member operators
 
-        inline exponentialSolidTransport& operator=
+        inline void operator=(const exponentialSolidTransport&);
-        (
-            const exponentialSolidTransport&
-        );
         inline void operator+=(const exponentialSolidTransport&);
         inline void operator-=(const exponentialSolidTransport&);
 

src/thermophysicalModels/solidSpecie/transport/exponential/exponentialSolidTransportI.H

@@ -111,8 +111,7 @@ alphah(const scalar p, const scalar T) const
 
 
 template<class Thermo>
-inline Foam::exponentialSolidTransport<Thermo>&
+inline void Foam::exponentialSolidTransport<Thermo>::operator=
-Foam::exponentialSolidTransport<Thermo>::operator=
 (
     const exponentialSolidTransport<Thermo>& ct
 )
@@ -120,7 +119,6 @@ Foam::exponentialSolidTransport<Thermo>::operator=
     kappa0_ = ct.kappa0_;
     n0_ = ct.n0_;
     Tref_ = ct.Tref_;
-    return *this;
 }
 
 

src/thermophysicalModels/solidSpecie/transport/polynomial/polynomialSolidTransport.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -172,10 +172,7 @@ public:
 
     // Member operators
 
-        inline polynomialSolidTransport& operator=
+        inline void operator=(const polynomialSolidTransport&);
-        (
-            const polynomialSolidTransport&
-        );
         inline void operator+=(const polynomialSolidTransport&);
         inline void operator-=(const polynomialSolidTransport&);
         inline void operator*=(const scalar);

src/thermophysicalModels/solidSpecie/transport/polynomial/polynomialSolidTransportI.H

@@ -148,8 +148,7 @@ inline Foam::scalar Foam::polynomialSolidTransport<Thermo, PolySize>::alphah
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Thermo, int PolySize>
-inline Foam::polynomialSolidTransport<Thermo, PolySize>&
+inline void Foam::polynomialSolidTransport<Thermo, PolySize>::operator=
-Foam::polynomialSolidTransport<Thermo, PolySize>::operator=
 (
     const polynomialSolidTransport<Thermo, PolySize>& pt
 )
@@ -157,8 +156,6 @@ Foam::polynomialSolidTransport<Thermo, PolySize>::operator=
     Thermo::operator=(pt);
 
     kappaCoeffs_ = pt.kappaCoeffs_;
-
-    return *this;
 }
 
 

src/thermophysicalModels/specie/equationOfState/Boussinesq/Boussinesq.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2015-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -194,10 +194,7 @@ public:
 
     // Member operators
 
-        inline Boussinesq& operator=
+        inline void operator=(const Boussinesq&);
-        (
-            const Boussinesq&
-        );
         inline void operator+=(const Boussinesq&);
         inline void operator-=(const Boussinesq&);
 

src/thermophysicalModels/specie/equationOfState/Boussinesq/BoussinesqI.H

@@ -167,8 +167,7 @@ inline Foam::scalar Foam::Boussinesq<Specie>::cpMcv
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Specie>
-inline Foam::Boussinesq<Specie>&
+inline void Foam::Boussinesq<Specie>::operator=
-Foam::Boussinesq<Specie>::operator=
 (
     const Boussinesq<Specie>& b
 )
@@ -178,10 +177,9 @@ Foam::Boussinesq<Specie>::operator=
     rho0_ = b.rho0_;
     T0_ = b.T0_;
     beta_ = b.beta_;
-
-    return *this;
 }
 
+
 template<class Specie>
 inline void Foam::Boussinesq<Specie>::operator+=
 (

src/thermophysicalModels/specie/equationOfState/icoPolynomial/icoPolynomial.H

@@ -176,7 +176,7 @@ public:
 
     // Member operators
 
-        inline icoPolynomial& operator=(const icoPolynomial&);
+        inline void operator=(const icoPolynomial&);
         inline void operator+=(const icoPolynomial&);
         inline void operator-=(const icoPolynomial&);
 

src/thermophysicalModels/specie/equationOfState/icoPolynomial/icoPolynomialI.H

@@ -157,8 +157,7 @@ inline Foam::scalar Foam::icoPolynomial<Specie, PolySize>::cpMcv
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Specie, int PolySize>
-inline Foam::icoPolynomial<Specie, PolySize>&
+inline void Foam::icoPolynomial<Specie, PolySize>::operator=
-Foam::icoPolynomial<Specie, PolySize>::operator=
 (
     const icoPolynomial<Specie, PolySize>& ip
 )
@@ -166,8 +165,6 @@ Foam::icoPolynomial<Specie, PolySize>::operator=
     Specie::operator=(ip);
 
     rhoCoeffs_ = ip.rhoCoeffs_;
-
-    return *this;
 }
 
 

src/thermophysicalModels/specie/equationOfState/incompressiblePerfectGas/incompressiblePerfectGas.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -179,10 +179,7 @@ public:
 
     // Member operators
 
-        inline incompressiblePerfectGas& operator=
+        inline void operator=(const incompressiblePerfectGas&);
-        (
-            const incompressiblePerfectGas&
-        );
         inline void operator+=(const incompressiblePerfectGas&);
         inline void operator-=(const incompressiblePerfectGas&);
 

src/thermophysicalModels/specie/equationOfState/incompressiblePerfectGas/incompressiblePerfectGasI.H

@@ -161,19 +161,16 @@ inline Foam::scalar Foam::incompressiblePerfectGas<Specie>::cpMcv
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Specie>
-inline Foam::incompressiblePerfectGas<Specie>&
+inline void Foam::incompressiblePerfectGas<Specie>::operator=
-Foam::incompressiblePerfectGas<Specie>::operator=
 (
     const incompressiblePerfectGas<Specie>& ipg
 )
 {
     Specie::operator=(ipg);
-
     pRef_ = ipg.pRef_;
-
-    return *this;
 }
 
+
 template<class Specie>
 inline void Foam::incompressiblePerfectGas<Specie>::operator+=
 (

src/thermophysicalModels/specie/thermo/hPolynomial/hPolynomialThermo.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -187,7 +187,7 @@ public:
 
     // Member operators
 
-        inline hPolynomialThermo& operator=(const hPolynomialThermo&);
+        inline void operator=(const hPolynomialThermo&);
         inline void operator+=(const hPolynomialThermo&);
         inline void operator-=(const hPolynomialThermo&);
         inline void operator*=(const scalar);

src/thermophysicalModels/specie/thermo/hPolynomial/hPolynomialThermoI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -144,8 +144,7 @@ inline Foam::scalar Foam::hPolynomialThermo<EquationOfState, PolySize>::s
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class EquationOfState, int PolySize>
-inline Foam::hPolynomialThermo<EquationOfState, PolySize>&
+inline void Foam::hPolynomialThermo<EquationOfState, PolySize>::operator=
-Foam::hPolynomialThermo<EquationOfState, PolySize>::operator=
 (
     const hPolynomialThermo<EquationOfState, PolySize>& pt
 )
@@ -157,8 +156,6 @@ Foam::hPolynomialThermo<EquationOfState, PolySize>::operator=
     CpCoeffs_ = pt.CpCoeffs_;
     hCoeffs_ = pt.hCoeffs_;
     sCoeffs_ = pt.sCoeffs_;
-
-    return *this;
 }
 
 

src/thermophysicalModels/specie/transport/const/constTransport.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -161,7 +161,7 @@ public:
 
     // Member operators
 
-        inline constTransport& operator=(const constTransport&);
+        inline void operator=(const constTransport&);
 
         inline void operator+=(const constTransport&);
 

src/thermophysicalModels/specie/transport/const/constTransportI.H

@@ -129,7 +129,7 @@ inline Foam::scalar Foam::constTransport<Thermo>::alphah
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Thermo>
-inline Foam::constTransport<Thermo>& Foam::constTransport<Thermo>::operator=
+inline void Foam::constTransport<Thermo>::operator=
 (
     const constTransport<Thermo>& ct
 )
@@ -138,8 +138,6 @@ inline Foam::constTransport<Thermo>& Foam::constTransport<Thermo>::operator=
 
     mu_ = ct.mu_;
     rPr_ = ct.rPr_;
-
-    return *this;
 }
 
 

src/thermophysicalModels/specie/transport/polynomial/polynomialTransport.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -166,7 +166,7 @@ public:
 
     // Member operators
 
-        inline polynomialTransport& operator=(const polynomialTransport&);
+        inline void operator=(const polynomialTransport&);
         inline void operator+=(const polynomialTransport&);
         inline void operator-=(const polynomialTransport&);
         inline void operator*=(const scalar);

src/thermophysicalModels/specie/transport/polynomial/polynomialTransportI.H

@@ -136,8 +136,7 @@ inline Foam::scalar Foam::polynomialTransport<Thermo, PolySize>::alphah
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Thermo, int PolySize>
-inline Foam::polynomialTransport<Thermo, PolySize>&
+inline void Foam::polynomialTransport<Thermo, PolySize>::operator=
-Foam::polynomialTransport<Thermo, PolySize>::operator=
 (
     const polynomialTransport<Thermo, PolySize>& pt
 )
@@ -146,8 +145,6 @@ Foam::polynomialTransport<Thermo, PolySize>::operator=
 
     muCoeffs_ = pt.muCoeffs_;
     kappaCoeffs_ = pt.kappaCoeffs_;
-
-    return *this;
 }
 
 

src/thermophysicalModels/specie/transport/sutherland/sutherlandTransport.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -186,7 +186,7 @@ public:
 
     // Member operators
 
-        inline sutherlandTransport& operator=(const sutherlandTransport&);
+        inline void operator=(const sutherlandTransport&);
 
         inline void operator+=(const sutherlandTransport&);
 

src/thermophysicalModels/specie/transport/sutherland/sutherlandTransportI.H

@@ -165,8 +165,7 @@ inline Foam::scalar Foam::sutherlandTransport<Thermo>::alphah
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Thermo>
-inline Foam::sutherlandTransport<Thermo>&
+inline void Foam::sutherlandTransport<Thermo>::operator=
-Foam::sutherlandTransport<Thermo>::operator=
 (
     const sutherlandTransport<Thermo>& st
 )
@@ -175,8 +174,6 @@ Foam::sutherlandTransport<Thermo>::operator=
 
     As_ = st.As_;
     Ts_ = st.Ts_;
-
-    return *this;
 }