[port]: re-write List container to suppress [-Walloc-size-larger-than=].

- Changes are ported from OpenFOAM-dev project.

src/foam/containers/Lists/List/List.C

@@ -50,15 +50,12 @@ Foam::List<T>::List(const label s)
 {
     if (this->size_ < 0)
     {
-        FatalErrorIn("List<T>::List(const label size)")
+        FatalErrorInFunction
             << "bad size " << this->size_
             << abort(FatalError);
     }
 
-    if (this->size_)
-    {
-        this->v_ = new T[this->size_];
-    }
+    alloc();
 }
 
 
@@ -70,15 +67,15 @@ Foam::List<T>::List(const label s, const T& a)
 {
     if (this->size_ < 0)
     {
-        FatalErrorIn("List<T>::List(const label size, const T&)")
+        FatalErrorInFunction
             << "bad size " << this->size_
             << abort(FatalError);
     }
 
+    alloc();
+
     if (this->size_)
     {
-        this->v_ = new T[this->size_];
-
         List_ACCESS(T, (*this), vp);
         List_FOR_ALL((*this), i)
             List_ELEM((*this), vp, i) = a;
@@ -95,7 +92,7 @@ Foam::List<T>::List(const List<T>& a)
 {
     if (this->size_)
     {
-        this->v_ = new T[this->size_];
+        alloc();
 
         #ifdef USEMEMCPY
         if (contiguous<T>())
@@ -125,11 +122,11 @@ Foam::List<T>::List(const Xfer< List<T> >& lst)
 
 // Construct as copy or re-use as specified.
 template<class T>
-Foam::List<T>::List(List<T>& a, bool reUse)
+Foam::List<T>::List(List<T>& a, bool reuse)
 :
     UList<T>(nullptr, a.size_)
 {
-    if (reUse)
+    if (reuse)
     {
         this->v_ = a.v_;
         a.v_ = 0;
@@ -137,7 +134,7 @@ Foam::List<T>::List(List<T>& a, bool reUse)
     }
     else if (this->size_)
     {
-        this->v_ = new T[this->size_];
+        alloc();
 
         #ifdef USEMEMCPY
         if (contiguous<T>())
@@ -167,11 +164,11 @@ Foam::List<T>::List(const UList<T>& a, const unallocLabelList& map)
     {
         // Note:cannot use List_ELEM since third argument has to be index.
 
-        this->v_ = new T[this->size_];
+        alloc();
 
         forAll(*this, i)
         {
-            this->v_[i] = a[map[i]];
+            this->operator[](i) = a[map[i]];
         }
     }
 }
@@ -181,32 +178,9 @@ Foam::List<T>::List(const UList<T>& a, const unallocLabelList& map)
 template<class T>
 template<class InputIterator>
 Foam::List<T>::List(InputIterator first, InputIterator last)
-{
-    label s = 0;
-    for
-    (
-        InputIterator iter = first;
-        iter != last;
-        ++iter
-    )
-    {
-        s++;
-    }
-
-    setSize(s);
-
-    s = 0;
-
-    for
-    (
-        InputIterator iter = first;
-        iter != last;
-        ++iter
-    )
-    {
-        this->operator[](s++) = iter();
-    }
-}
+:
+    List<T>(first, last, std::distance(first, last))
+{}
 
 
 // Construct as copy of FixedList<T, Size>
@@ -216,15 +190,7 @@ Foam::List<T>::List(const FixedList<T, Size>& lst)
 :
     UList<T>(nullptr, Size)
 {
-    if (this->size_)
-    {
-        this->v_ = new T[this->size_];
-
-        forAll(*this, i)
-        {
-            this->operator[](i) = lst[i];
-        }
-    }
+    allocCopyList(lst);
 }
 
 
@@ -234,15 +200,7 @@ Foam::List<T>::List(const PtrList<T>& lst)
 :
     UList<T>(nullptr, lst.size())
 {
-    if (this->size_)
-    {
-        this->v_ = new T[this->size_];
-
-        forAll(*this, i)
-        {
-            this->operator[](i) = lst[i];
-        }
-    }
+    allocCopyList(lst);
 }
 
 
@@ -254,7 +212,7 @@ Foam::List<T>::List(const SLList<T>& lst)
 {
     if (this->size_)
     {
-        this->v_ = new T[this->size_];
+        alloc();
 
         label i = 0;
         for
@@ -276,15 +234,7 @@ Foam::List<T>::List(const IndirectList<T>& lst)
 :
     UList<T>(nullptr, lst.size())
 {
-    if (this->size_)
-    {
-        this->v_ = new T[this->size_];
-
-        forAll(*this, i)
-        {
-            this->operator[](i) = lst[i];
-        }
-    }
+    allocCopyList(lst);
 }
 
 
@@ -294,15 +244,7 @@ Foam::List<T>::List(const UIndirectList<T>& lst)
 :
     UList<T>(nullptr, lst.size())
 {
-    if (this->size_)
-    {
-        this->v_ = new T[this->size_];
-
-        forAll(*this, i)
-        {
-            this->operator[](i) = lst[i];
-        }
-    }
+    allocCopyList(lst);
 }
 
 
@@ -312,15 +254,7 @@ Foam::List<T>::List(const BiIndirectList<T>& lst)
 :
     UList<T>(nullptr, lst.size())
 {
-    if (this->size_)
-    {
-        this->v_ = new T[this->size_];
-
-        forAll(*this, i)
-        {
-            this->operator[](i) = lst[i];
-        }
-    }
+    allocCopyList(lst);
 }
 
 

src/foam/containers/Lists/List/List.H

@@ -80,6 +80,27 @@ class List
     public UList<T>
 {
 
+    // Private member functions
+
+        //- Allocate list storage
+        inline void alloc();
+
+        //- Reallocate list storage to the given size
+        inline void reAlloc(const label s);
+
+        //- Copy list of given type
+        template<class List2>
+        inline void copyList(const List2&);
+
+        //- Allocate storage and copy list of given type
+        template<class List2>
+        inline void allocCopyList(const List2&);
+
+        //- Construct given start and end iterators and number of elements
+        template<class InputIterator>
+        inline List(InputIterator first, InputIterator last, const label s);
+
+
 protected:
 
     //- Override size to be inconsistent with allocated storage.
@@ -118,7 +139,7 @@ public:
         List(const Xfer< List<T> >&);
 
         //- Construct as copy or re-use as specified.
-        List(List<T>&, bool reUse);
+        List(List<T>&, bool reuse);
 
         //- Construct as subset.
         List(const UList<T>&, const unallocLabelList& mapAddressing);

src/foam/containers/Lists/List/ListI.H

@@ -23,6 +23,81 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class T>
+inline void Foam::List<T>::alloc()
+{
+    if (this->size_ > 0)
+    {
+        this->v_ = new T[this->size_];
+    }
+}
+
+
+template<class T>
+inline void Foam::List<T>::reAlloc(const label s)
+{
+    if (this->size_ != s)
+    {
+        clear();
+        this->size_ = s;
+        alloc();
+    }
+}
+
+
+template<class T>
+template<class List2>
+inline void Foam::List<T>::copyList(const List2& lst)
+{
+    if (this->size_)
+    {
+        forAll(*this, i)
+        {
+            this->operator[](i) = lst[i];
+        }
+    }
+}
+
+
+template<class T>
+template<class List2>
+inline void Foam::List<T>::allocCopyList(const List2& lst)
+{
+    if (this->size_)
+    {
+        alloc();
+        copyList(lst);
+    }
+}
+
+
+template<class T>
+template<class InputIterator>
+inline Foam::List<T>::List
+(
+    InputIterator first,
+    InputIterator last,
+    const label s
+)
+:
+    UList<T>(nullptr, s)
+{
+    if (this->size_)
+    {
+        alloc();
+
+        InputIterator iter = first;
+        forAll(*this, i)
+        {
+            this->operator[](i) = *iter;
+            ++iter;
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class T>