ENH: align bitSet and FixedList methods names

- bitSet and PackedList fill() as per boost dynamic_bitset.
  Silently deprecate assign(val), which is potentially confusing
  with other forms of assign().

- FixedList fill() as per std::array.
  Add missing assignment from Foam::zero

- minor code simplication in bitSet and PackedList

STYLE: fix typo in comment, qualify Foam::zero

src/OpenFOAM/containers/Bits/PackedList/PackedList.C

@@ -123,10 +123,10 @@ bool Foam::PackedList<Width>::uniform() const
     }
     else if (nblocks > 1)
     {
-        // Check all blocks that are completely occupied: (nblocks-1)
-        const unsigned int blockval =
-            BitOps::repeat_value<block_type,Width>(val);
+        // Fill value for complete blocks
+        const unsigned int blockval = repeated_value(val);
 
+        // Check each complete block (nblocks-1)
         for (label blocki = 0; identical && blocki < (nblocks-1); ++blocki)
         {
             identical = (blocks_[blocki] == blockval);

src/OpenFOAM/containers/Bits/PackedList/PackedList.H

@@ -109,9 +109,6 @@ namespace Foam
 template<unsigned Width> class PackedList;
 class labelRange;
 
-class Istream;
-class Ostream;
-
 template<unsigned Width>
 Istream& operator>>(Istream& is, PackedList<Width>& list);
 
@@ -136,9 +133,11 @@ public:
     // Types and dimension information
 
         //- The storage block type for bit elements
+        //  \note Type name compatibility with boost::dynamic_bitset
         typedef unsigned int block_type;
 
         //- The number of bits in a single block
+        //  \note Type name compatibility with boost::dynamic_bitset
         static constexpr unsigned bits_per_block
             = (std::numeric_limits<block_type>::digits);
 
@@ -219,6 +218,9 @@ protected:
         //  This \a rubbish may have arisen from block-wise operations etc.
         inline void clear_trailing_bits();
 
+        //- Copy assignment
+        inline void copyAssign(const PackedList<Width>& rhs);
+
 
 public:
 
@@ -335,11 +337,8 @@ public:
 
     // Edit
 
-        //- Assign all entries to the given value. Takes linear time.
-        inline void assign(const unsigned int val);
-
-        //- Copy assignment.
-        inline void assign(const PackedList<Width>& rhs);
+        //- Assign all entries to the given value.
+        inline void fill(const unsigned int val);
 
         //- Trim any trailing zero elements, optionally specifying a
         //- a minimum position, below which trimming will not occur.
@@ -348,6 +347,7 @@ public:
         inline bool trim(label minpos=-1);
 
         //- Clear all bits but do not adjust the addressable size.
+        //  \note Method name compatibility with boost::dynamic_bitset
         inline void reset();
 
         //- Alter the size of the underlying storage.
@@ -359,9 +359,6 @@ public:
         //  Optionally specify a value for new elements.
         inline void resize(const label nElem, const unsigned int val = 0u);
 
-        //- Alias for resize()
-        inline void setSize(const label nElem, const unsigned int val = 0u);
-
         //- Reserve allocation space for at least this size.
         //  Never shrinks the allocated size.
         //  The list size is adjusted as per DynamicList with
@@ -382,7 +379,7 @@ public:
         inline void swap(PackedList<Width>& rhs);
 
         //- Transfer the contents of the argument list into this list
-        //  and annul the argument list.
+        //- and annul the argument list.
         inline void transfer(PackedList<Width>& rhs);
 
 
@@ -435,15 +432,15 @@ public:
         //  Fatal for out-of-range indices
         inline reference operator[](const label i);
 
-        //- Assignment of all entries to the given value. Takes linear time.
-        inline void operator=(const unsigned int val);
-
         //- Copy assignment.
         inline void operator=(const PackedList<Width>& lst);
 
         //- Move assignment.
         inline void operator=(PackedList<Width>&& lst);
 
+        //- Assign all entries to the given value. fill()
+        inline void operator=(const unsigned int val);
+
 
     // Access helpers
 
@@ -509,6 +506,23 @@ public:
             Istream& is,
             PackedList<Width>& list
         );
+
+
+    // Housekeeping
+
+        //- Deprecated(2020-11) use fill()
+        //  \deprecated(2020-11) use fill()
+        void assign(const unsigned int val) { this->fill(val); }
+
+        //- Deprecated(2020-11) use operator=
+        //  \deprecated(2020-11) use operator=
+        void assign(const PackedList<Width>& rhs) { (*this) = rhs; }
+
+        //- Alias for resize()
+        void setSize(const label len, unsigned int val = 0u)
+        {
+            resize(len, val);
+        }
 };
 
 

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -138,24 +138,35 @@ inline bool Foam::PackedList<Width>::trim(label minpos)
 }
 
 
+template<unsigned Width>
+inline void Foam::PackedList<Width>::copyAssign(const PackedList<Width>& rhs)
+{
+    // Self-assignment silently ignored
+    blocks_ = rhs.blocks_;
+    size_ = rhs.size_;
+}
+
+
 // * * * * * * * * * * * * * * * Specializations * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    template<> inline unsigned int PackedList<1>::repeated_value(unsigned val)
-    {
-        return (val ? ~0u : 0u);
-    }
 
-    template<> inline unsigned int PackedList<1>::readValue(Istream& is)
-    {
-        return readBool(is);
-    }
+// constexpr noexcept
+template<> inline unsigned int PackedList<1>::repeated_value(unsigned val)
+{
+    return (val ? ~0u : 0u);
+}
 
-    template<> inline void PackedList<1>::setPair(Istream& is)
-    {
-        set(readLabel(is), true);
-    }
+template<> inline unsigned int PackedList<1>::readValue(Istream& is)
+{
+    return readBool(is);
+}
+
+template<> inline void PackedList<1>::setPair(Istream& is)
+{
+    set(readLabel(is), true);
+}
 
 } // End namespace Foam
 
@@ -446,17 +457,6 @@ inline void Foam::PackedList<Width>::resize
 }
 
 
-template<unsigned Width>
-inline void Foam::PackedList<Width>::setSize
-(
-    const label newSize,
-    const unsigned int val
-)
-{
-    resize(newSize, val);
-}
-
-
 template<unsigned Width>
 inline void Foam::PackedList<Width>::setCapacity(const label numElem)
 {
@@ -680,41 +680,27 @@ inline unsigned int Foam::PackedList<Width>::remove()
 
 
 template<unsigned Width>
-inline void Foam::PackedList<Width>::assign(const unsigned int val)
+inline void Foam::PackedList<Width>::fill(const unsigned int val)
 {
+    if (empty())
+    {
+        return;  // Trivial case
+    }
+
     const label nblocks = num_blocks(size());
 
-    // Trivial cases first
-    if (!nblocks)
-    {
-        return;
-    }
-    else if (!val)
-    {
-        for (label blocki=0; blocki < nblocks; ++blocki)
-        {
-            blocks_[blocki] = 0u;
-        }
-        return;
-    }
-
     // Fill value for complete blocks
-    const unsigned int blockval = repeated_value(val);
+    const unsigned int blockval = (val ? repeated_value(val) : 0u);
 
     for (label blocki=0; blocki < nblocks; ++blocki)
     {
         blocks_[blocki] = blockval;
     }
 
-    clear_trailing_bits();
-}
-
-
-template<unsigned Width>
-inline void Foam::PackedList<Width>::assign(const PackedList<Width>& list)
-{
-    blocks_ = list.blocks_;
-    size_ = list.size_;
+    if (val)
+    {
+        clear_trailing_bits();
+    }
 }
 
 
@@ -738,17 +724,10 @@ Foam::PackedList<Width>::operator[](const label i)
 }
 
 
-template<unsigned Width>
-inline void Foam::PackedList<Width>::operator=(const unsigned int val)
-{
-    assign(val);
-}
-
-
 template<unsigned Width>
 inline void Foam::PackedList<Width>::operator=(const PackedList<Width>& rhs)
 {
-    assign(rhs);
+    copyAssign(rhs);
 }
 
 
@@ -759,6 +738,13 @@ inline void Foam::PackedList<Width>::operator=(PackedList<Width>&& rhs)
 }
 
 
+template<unsigned Width>
+inline void Foam::PackedList<Width>::operator=(const unsigned int val)
+{
+    fill(val);
+}
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 template<unsigned Width>

src/OpenFOAM/containers/Bits/bitSet/bitSet.C

@@ -329,8 +329,8 @@ void Foam::bitSet::assign(const UList<bool>& bools)
 {
     const label len = bools.size();
 
+    clear();
     resize(len);
-    assign(false);
 
     // Could also handle block-wise (in the future?)
 

src/OpenFOAM/containers/Bits/bitSet/bitSet.H

@@ -56,7 +56,6 @@ namespace Foam
 
 // Forward Declarations
 class bitSet;
-class labelRange;
 
 /*---------------------------------------------------------------------------*\
                            Class bitSet Declaration
@@ -66,8 +65,6 @@ class bitSet
 :
     public PackedList<1>
 {
-private:
-
     // Private Member Functions
 
         //- Find the first block with a '0' bit
@@ -218,12 +215,15 @@ public:
     // Query
 
         //- True if all bits in this bitset are set or if the set is empty.
+        //  \note Method name compatibility with boost::dynamic_bitset
         inline bool all() const;
 
         //- True if any bits in this bitset are set.
+        //  \note Method name compatibility with boost::dynamic_bitset
         inline bool any() const;
 
         //- True if no bits in this bitset are set.
+        //  \note Method name compatibility with boost::dynamic_bitset
         inline bool none() const;
 
         //- True if all entries have identical values, and the set is non-empty
@@ -232,6 +232,7 @@ public:
         //- Count number of bits set.
         //  \param on can be set to false to count the number of unset bits
         //     instead.
+        //  \note Method name compatibility with boost::dynamic_bitset
         inline unsigned int count(const bool on=true) const;
 
         //- True if any bits in the other bitset intersect (are the same).
@@ -292,7 +293,7 @@ public:
     // Assignment
 
         //- Assign all entries to the given value.
-        inline void assign(const bool val);
+        inline void fill(const bool val);
 
         //- Copy assign all entries from a list of bools.
         void assign(const UList<bool>& bools);
@@ -544,15 +545,15 @@ public:
         //  Fatal for out-of-range indices
         inline reference operator[](const label i);
 
-        //- Assignment of all entries to the given value.
-        inline bitSet& operator=(const bool val);
-
         //- Copy assignment
         inline bitSet& operator=(const bitSet& bitset);
 
         //- Move assignment
         inline bitSet& operator=(bitSet&& bitset);
 
+        //- Assign all entries to the given value. fill()
+        inline bitSet& operator=(const bool val);
+
         //- Bitwise-AND all the bits in other with the bits in this bitset.
         //  The operands may have dissimilar sizes without affecting the size
         //  of the set.
@@ -591,6 +592,13 @@ public:
         {
             return *this;
         }
+
+
+    // Housekeeping
+
+        //- Deprecated(2020-11) use fill()
+        //  \deprecated(2020-11) use fill()
+        void assign(const unsigned int val) { this->fill(val); }
 };
 
 

src/OpenFOAM/containers/Bits/bitSet/bitSetI.H

@@ -90,7 +90,7 @@ inline Foam::bitSet::bitSet(const label n, const bool val)
 :
     bitSet(n)
 {
-    if (val) assign(val);
+    if (val) fill(val);
 }
 
 
@@ -539,7 +539,7 @@ inline void Foam::bitSet::transfer(bitSet& bitset)
 }
 
 
-inline void Foam::bitSet::assign(const bool val)
+inline void Foam::bitSet::fill(const bool val)
 {
     if (empty())
     {
@@ -548,21 +548,18 @@ inline void Foam::bitSet::assign(const bool val)
 
     const label nblocks = num_blocks(size());
 
+    // Fill value for complete blocks
+    const unsigned int blockval = (val ? ~0u : 0u);
+
+    for (label blocki=0; blocki < nblocks; ++blocki)
+    {
+        blocks_[blocki] = blockval;
+    }
+
     if (val)
     {
-        for (label blocki=0; blocki < nblocks; ++blocki)
-        {
-            blocks_[blocki] = (~0u);
-        }
         clear_trailing_bits();
     }
-    else
-    {
-        for (label blocki=0; blocki < nblocks; ++blocki)
-        {
-            blocks_[blocki] = (0u);
-        }
-    }
 }
 
 
@@ -691,13 +688,6 @@ inline Foam::bitSet::reference Foam::bitSet::operator[](const label i)
 }
 
 
-inline Foam::bitSet& Foam::bitSet::operator=(const bool val)
-{
-    PackedList<1>::operator=(val);
-    return *this;
-}
-
-
 inline Foam::bitSet& Foam::bitSet::operator=(const bitSet& bitset)
 {
     PackedList<1>::operator=(bitset);
@@ -712,6 +702,13 @@ inline Foam::bitSet& Foam::bitSet::operator=(bitSet&& bitset)
 }
 
 
+inline Foam::bitSet& Foam::bitSet::operator=(const bool val)
+{
+    fill(val);
+    return *this;
+}
+
+
 inline Foam::bitSet& Foam::bitSet::operator&=(const bitSet& other)
 {
     return andEq(other);

src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H

@@ -90,7 +90,7 @@ template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
     const label nElem,
-    const zero
+    const Foam::zero
 )
 :
     List<T>(nElem, Zero),
@@ -762,7 +762,7 @@ inline void Foam::DynamicList<T, SizeMin>::operator=
 template<class T, int SizeMin>
 inline void Foam::DynamicList<T, SizeMin>::operator=
 (
-    const zero
+    const Foam::zero
 )
 {
     UList<T>::operator=(Zero);

src/OpenFOAM/containers/Lists/FixedList/FixedList.H

@@ -275,12 +275,18 @@ public:
 
     // Edit
 
-        //- Dummy resize function, to make FixedList consistent with List
+        //- Dummy function, to make FixedList consistent with List
         inline void resize(const label n);
 
-        //- Dummy setSize function, to make FixedList consistent with List
+        //- Dummy function, to make FixedList consistent with List
         inline void setSize(const label n);
 
+        //- Assign all entries to the given value
+        inline void fill(const T& val);
+
+        //- Assign all entries to zero
+        inline void fill(const Foam::zero);
+
         //- Move element to the first position.
         void moveFirst(const label i);
 
@@ -318,9 +324,12 @@ public:
         //- Assignment to an initializer list. Takes linear time
         inline void operator=(std::initializer_list<T> list);
 
-        //- Assignment of all entries to the given value
+        //- Assign all entries to the given value. fill()
         inline void operator=(const T& val);
 
+        //- Assign all entries to zero. fill()
+        inline void operator=(const Foam::zero);
+
         //- Copy assignment
         inline void operator=(const FixedList<T, N>& list);
 

src/OpenFOAM/containers/Lists/FixedList/FixedListI.H

@@ -45,20 +45,14 @@ inline const Foam::FixedList<T, N>& Foam::FixedList<T, N>::null()
 template<class T, unsigned N>
 inline Foam::FixedList<T, N>::FixedList(const T& val)
 {
-    for (unsigned i=0; i<N; ++i)
-    {
-        v_[i] = val;
-    }
+    this->fill(val);
 }
 
 
 template<class T, unsigned N>
 inline Foam::FixedList<T, N>::FixedList(const Foam::zero)
 {
-    for (unsigned i=0; i<N; ++i)
-    {
-        v_[i] = Zero;
-    }
+    this->fill(Zero);
 }
 
 
@@ -342,6 +336,26 @@ inline void Foam::FixedList<T, N>::setSize(const label n)
 }
 
 
+template<class T, unsigned N>
+inline void Foam::FixedList<T, N>::fill(const T& val)
+{
+    for (unsigned i=0; i<N; ++i)
+    {
+        v_[i] = val;
+    }
+}
+
+
+template<class T, unsigned N>
+inline void Foam::FixedList<T, N>::fill(const Foam::zero)
+{
+    for (unsigned i=0; i<N; ++i)
+    {
+        v_[i] = Zero;
+    }
+}
+
+
 template<class T, unsigned N>
 inline void Foam::FixedList<T, N>::swap(FixedList<T, N>& list)
 {
@@ -443,12 +457,17 @@ inline void Foam::FixedList<T, N>::operator=(std::initializer_list<T> list)
 template<class T, unsigned N>
 inline void Foam::FixedList<T, N>::operator=(const T& val)
 {
-    for (unsigned i=0; i<N; ++i)
-    {
-        v_[i] = val;
-    }
+    this->fill(val);
 }
 
+
+template<class T, unsigned N>
+inline void Foam::FixedList<T, N>::operator=(const Foam::zero)
+{
+    this->fill(Zero);
+}
+
+
 template<class T, unsigned N>
 inline void Foam::FixedList<T, N>::operator=(const FixedList<T, N>& list)
 {

src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynList.H

@@ -93,7 +93,7 @@ public:
         //- Move construct
         inline PtrDynList(PtrDynList<T, SizeMin>&& list);
 
-        //- Take ownerskip of pointers in the list, set old pointers to null.
+        //- Take ownership of pointers in the list, set old pointers to null.
         inline explicit PtrDynList(UList<T*>& list);
 
 

src/OpenFOAM/containers/PtrLists/PtrList/PtrList.H

@@ -99,7 +99,7 @@ public:
         //- Move construct
         inline PtrList(PtrList<T>&& list);
 
-        //- Take ownerskip of pointers in the list, set old pointers to null.
+        //- Take ownership of pointers in the list, set old pointers to null.
         inline explicit PtrList(UList<T*>& list);
 
         //- Copy construct using 'clone()' method on each element

src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H

@@ -90,7 +90,7 @@ template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>::DynamicField
 (
     const label len,
-    const zero
+    const Foam::zero
 )
 :
     Field<T>(len, Zero),