ENH: improvements for PtrList, UPtrList and new PtrDynList container

- improve internal handling to permit deriving resizable containers
  (eg, PtrDynList).

- include '->' iterator dereferencing

- Only append/set non-const autoPtr references. This doesn't break
  existing code, but makes the intention more transparent.

applications/test/PtrList/Test-PtrList.C

@@ -29,7 +29,7 @@ Description
 
 #include "scalar.H"
 #include "IOstreams.H"
-#include "PtrList.H"
+#include "PtrDynList.H"
 #include "DLPtrList.H"
 #include "SLPtrList.H"
 #include "plane.H"
@@ -58,6 +58,16 @@ public:
         Info<<"delete Scalar: " << data_ << endl;
     }
 
+    const scalar& value() const
+    {
+        return data_;
+    }
+
+    scalar& value()
+    {
+        return data_;
+    }
+
     autoPtr<Scalar> clone() const
     {
         return autoPtr<Scalar>::New(data_);
@@ -71,6 +81,151 @@ public:
 };
 
 
+
+// As per
+//
+//     template<class T>
+//     Ostream& operator<<(Ostream& os, const UPtrList<T>& list)
+//
+// but handle nullptr
+
+template<class T>
+Ostream& printAddr
+(
+    Ostream& os,
+    const UPtrList<T>& list
+)
+{
+    const label len = list.size();
+
+    // Size and start delimiter
+    os  << nl << indent << len << nl
+        << indent << token::BEGIN_LIST << incrIndent << nl;
+
+    for (label i=0; i < len; ++i)
+    {
+        os << "addr=" << long(list(i)) << nl;
+    }
+
+    // End delimiter
+    os << decrIndent << indent << token::END_LIST << nl;
+    return os;
+}
+
+
+// As per
+//
+//     template<class T>
+//     Ostream& operator<<(Ostream& os, const UPtrList<T>& list)
+//
+// but handle nullptr
+
+template<class T>
+Ostream& print
+(
+    Ostream& os,
+    const UPtrList<T>& list,
+    const bool debug=false
+)
+{
+    const label len = list.size();
+
+    // Size and start delimiter
+    os  << nl << indent << len << nl
+        << indent << token::BEGIN_LIST << incrIndent << nl;
+
+    for (label i=0; i < len; ++i)
+    {
+        const T* ptr = list(i);
+
+        if (ptr)
+        {
+            os << *ptr << nl;
+        }
+        else
+        {
+            os << "nullptr" << nl;
+        }
+    }
+
+    // End delimiter
+    os << decrIndent << indent << token::END_LIST << nl;
+    return os;
+}
+
+
+template<class T, int SizeMin>
+Ostream& print
+(
+    Ostream& os,
+    const PtrDynList<T, SizeMin>& list,
+    const bool debug=false
+)
+{
+    const label len = list.size();
+
+    // Size and start delimiter
+    os  << nl << indent << len << nl
+        << indent << token::BEGIN_LIST << incrIndent << nl;
+
+    for (label i=0; i < len; ++i)
+    {
+        const T* ptr = list(i);
+
+        if (ptr)
+        {
+            os << *ptr << nl;
+        }
+        else
+        {
+            os << "nullptr" << nl;
+        }
+    }
+
+    if (debug)
+    {
+        const label cap = list.capacity();
+
+        for (label i=len; i < cap; ++i)
+        {
+            const T* ptr = list(i);
+
+            os << "unused " << long(ptr) << nl;
+        }
+    }
+
+
+    // End delimiter
+    os << decrIndent << indent << token::END_LIST << nl;
+    return os;
+}
+
+
+template<class T>
+Ostream& report
+(
+    Ostream& os,
+    const UPtrList<T>& list,
+    const bool debug=false
+)
+{
+    return print(os, list, debug);
+}
+
+
+template<class T, int SizeMin>
+Ostream& report
+(
+    Ostream& os,
+    const PtrDynList<T,SizeMin>& list,
+    const bool debug=false
+)
+{
+    os << "capacity=" << list.capacity() << nl;
+    return print(os, list, debug);
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
@@ -110,6 +265,23 @@ int main(int argc, char *argv[])
         }
     }
 
+    // Same but as SLPtrList
+    {
+        SLPtrList<Scalar> llist1;
+        llist1.insert(new Scalar(100));
+        llist1.insert(new Scalar(200));
+        llist1.insert(new Scalar(300));
+
+        for (const auto& it : llist1)
+        {
+            Info<< typeid(it).name() << nl
+                << "for-: " << it << endl;
+        }
+
+        PtrList<Scalar> list1b(llist1);
+        Info<< list1b << endl;
+    }
+
     forAll(list1, i)
     {
         list1.set(i, new Scalar(1.3*i));
@@ -133,7 +305,7 @@ int main(int argc, char *argv[])
     Info<<"indirectly delete some items via set(.., 0) :" << endl;
     for (label i = 0; i < 3; i++)
     {
-        list1.set(i, 0);
+        list1.set(i, nullptr);
     }
 
     Info<<"transfer list2 -> list1:" << endl;
@@ -147,6 +319,36 @@ int main(int argc, char *argv[])
 
     Info<<"list1: " << list1 << endl;
 
+    {
+        PtrList<Scalar> list1a(list1, false);
+
+        Info<<"Clone constructed" << endl;
+        Info<<"in:  " << list1 << nl
+            <<"out: " << list1a << nl
+            <<"addresses:" << nl;
+        printAddr(Info, list1);
+        printAddr(Info, list1a);
+
+        PtrList<Scalar> list1b(list1a, true);
+
+        Info<<"Reuse constructed" << endl;
+        Info<<"in:  " << list1a << nl
+            <<"out: " << list1b << nl
+            <<"addresses:" << nl;
+        printAddr(Info, list1a);
+        printAddr(Info, list1b);
+
+
+        PtrList<Scalar> list1c(list1b.clone());
+
+        Info<<"Explicit clone()" << endl;
+        Info<<"in:  " << list1b << nl
+            <<"out: " << list1c << nl
+            <<"addresses:" << nl;
+        printAddr(Info, list1b);
+        printAddr(Info, list1c);
+    }
+
     PtrList<Scalar> list3(std::move(list1));
     Info<<"Move constructed" << endl;
 
@@ -174,6 +376,26 @@ int main(int argc, char *argv[])
     UPtrList<Scalar> ulist1(list3);
 
     Info<<"ulist1: " << ulist1 << nl;
+    Info<<"PtrList addresses:";
+    printAddr(Info, list3);
+    Info<<"UPtrList addresses:";
+    printAddr(Info, ulist1);
+    Info<< nl;
+
+    {
+        Info<<"UPtrList(const UPtrList&)" << nl;
+
+        const UPtrList<Scalar>& cref = ulist1;
+
+        UPtrList<Scalar> ulist1cp(cref);
+
+        Info<<"src addresses:";
+        printAddr(Info, cref);
+        Info<<"dst addresses:";
+        printAddr(Info, ulist1cp);
+        Info<< nl;
+    }
+
 
     Info<<"Move construct:" << endl;
 
@@ -204,6 +426,10 @@ int main(int argc, char *argv[])
         Info<< "iter[2]=" << iter1[2] << nl;
         Info<< "iter1 < iter2 : " << (iter1 < iter2) << nl;
         Info<< "iter1 >= iter2 : " << (iter1 >= iter2) << nl;
+
+        Info<<"->" << iter1->value() << nl;
+        Info<<"*"  << (*iter1).value() << nl;
+        Info<<"()" << iter1().value() << nl;
     }
 
     PtrList<plane> planes;
@@ -216,6 +442,46 @@ int main(int argc, char *argv[])
         Info<< "    plane " << p << endl;
     }
 
+    Info<<"Testing PtrDynList" << nl;
+
+    PtrDynList<plane> dynPlanes;
+
+    {
+        dynPlanes.append(new plane(vector::one, vector::one));
+        dynPlanes.append(new plane(vector(1,2,3), vector::one));
+        dynPlanes.append(nullptr);
+
+        dynPlanes.set(6, new plane(vector(2,2,1), vector::one));
+        dynPlanes.set(10, new plane(vector(4,5,6), vector::one));
+    }
+
+    Info<< nl << "PtrList: ";
+    report(Info, dynPlanes, true);
+
+    dynPlanes.resize(9);
+
+    Info<< nl << "resize()";
+    report(Info, dynPlanes, true);
+
+    dynPlanes.clear();
+    Info<<"clear()" << nl;
+    report(Info, dynPlanes);
+
+    Info<<"now append again" << endl;
+    {
+        dynPlanes.append(new plane(vector::one, vector::one));
+        dynPlanes.append(new plane(vector(1,2,3), vector::one));
+
+        dynPlanes.set(5, new plane(vector(2,2,1), vector::one));
+    }
+
+    report(Info, dynPlanes, true);
+
+    Info<<"free()" << endl;
+
+    dynPlanes.free();
+    report(Info, dynPlanes, true);
+
     Info<< nl << "Done." << endl;
     return 0;
 }

applications/utilities/mesh/conversion/gambitToFoam/gambitToFoam.L

@@ -57,8 +57,6 @@ using namespace Foam;
 #include "emptyPolyPatch.H"
 #include "preservePatchTypes.H"
 #include "cellShape.H"
-#include "SLList.H"
-#include "SLPtrList.H"
 
 label nPoints = 0;
 label nCells = 0;

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

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::PtrDynList
+
+Description
+    A dynamically resizable PtrList with allocation management.
+
+See Also
+    Foam::UPtrList
+    Foam::PtrList
+
+SourceFiles
+    PtrDynListI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef PtrDynList_H
+#define PtrDynList_H
+
+#include "PtrList.H"
+#include <type_traits>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declarations
+
+template<class T, int SizeMin> class PtrDynList;
+
+/*---------------------------------------------------------------------------*\
+                         Class PtrDynList Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class T, int SizeMin=64>
+class PtrDynList
+:
+    public PtrList<T>
+{
+    static_assert(SizeMin > 0, "Invalid min size parameter");
+
+    // Private data
+
+        //- The capacity (allocated size) of the list.
+        label capacity_;
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        inline constexpr PtrDynList() noexcept;
+
+        //- Construct with given capacity.
+        explicit inline PtrDynList(const label len);
+
+        //- Copy construct using 'clone()' method on each element
+        inline PtrDynList(const PtrDynList<T, SizeMin>& list);
+
+        //- Move construct
+        inline PtrDynList(PtrDynList<T, SizeMin>&& list);
+
+
+    //- Destructor
+    ~PtrDynList() = default;
+
+
+    // Member Functions
+
+    // Access
+
+        //- Size of the underlying storage.
+        inline label capacity() const;
+
+    // Edit
+
+        //- Delete the allocated entries, but retain the list size.
+        using PtrList<T>::free;
+
+        //- Alter the size of the underlying storage.
+        inline void setCapacity(const label nElem);
+
+        //- Alter the addressed list size.
+        inline void resize(const label newLen);
+
+        //- Alter the addressed list size.
+        inline void setSize(const label newLen);
+
+        //- Reserve allocation space for at least this size.
+        //  Never shrinks the allocated size, use setCapacity() for that.
+        inline void reserve(const label nElem);
+
+        //- Clear the addressed list, i.e. set the size to zero.
+        //  Allocated size does not change
+        inline void clear();
+
+        //- Clear the list and delete storage.
+        inline void clearStorage();
+
+        //- Expand the addressable size to fit the allocated capacity.
+        //  Returns the previous addressable size.
+        inline label expandStorage();
+
+        //- Shrink the allocated space to the number of elements used.
+        inline void shrink();
+
+        //- Append an element to the end of the list
+        inline void append(T* ptr);
+
+        //- Append an element to the end of the list
+        inline void append(const autoPtr<T>& aptr);
+
+        //- Append an element to the end of the list
+        inline void append(const tmp<T>& tptr);
+
+        //- Remove and return the top element
+        inline autoPtr<T> remove();
+
+        //- Return true if element is set (ie, not a nullptr)
+        inline bool set(const label i) const;
+
+        //- Set element to given pointer and return old element (can be null)
+        inline autoPtr<T> set(const label i, T* ptr);
+
+        //- Set element to given autoPtr and return old element
+        inline autoPtr<T> set(const label i, const autoPtr<T>& aptr);
+
+        //- Set element to given tmp and return old element
+        inline autoPtr<T> set(const label i, const tmp<T>& tptr);
+
+        //- Reorder elements. Reordering must be unique (ie, shuffle).
+        inline void reorder(const labelUList& oldToNew);
+
+
+    // Member Operators
+
+        //- Copy (clone) assignment
+        inline void operator=(const PtrList<T>& list);
+
+        //- Copy (clone) assignment
+        inline void operator=(const PtrDynList<T, SizeMin>& list);
+
+        //- Copy (clone) assignment with different sizing parameters
+        template<int AnySizeMin>
+        inline void operator=(const PtrDynList<T, AnySizeMin>& list);
+
+        //- Move assignment
+        inline void operator=(PtrList<T>&& list);
+
+        //- Move assignment
+        inline void operator=(PtrDynList<T, SizeMin>&& list);
+
+        //- Move assignment with different sizing parameters
+        template<int AnySizeMin>
+        inline void operator=(PtrDynList<T, AnySizeMin>&& list);
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "PtrDynListI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

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

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "autoPtr.H"
+#include "tmp.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class T, int SizeMin>
+inline constexpr Foam::PtrDynList<T, SizeMin>::PtrDynList() noexcept
+:
+    PtrList<T>(),
+    capacity_(0)
+{}
+
+
+template<class T, int SizeMin>
+inline Foam::PtrDynList<T, SizeMin>::PtrDynList(const label len)
+:
+    PtrList<T>(len),
+    capacity_(len)
+{
+    PtrList<T>::size(0);
+}
+
+
+template<class T, int SizeMin>
+inline Foam::PtrDynList<T, SizeMin>::PtrDynList
+(
+    const PtrDynList<T, SizeMin>& list
+)
+:
+    PtrList<T>(list),
+    capacity_(PtrList<T>::size())
+{}
+
+
+template<class T, int SizeMin>
+inline Foam::PtrDynList<T, SizeMin>::PtrDynList
+(
+    PtrDynList<T, SizeMin>&& list
+)
+:
+    PtrList<T>(std::move(list)),
+    capacity_(list.capacity_)
+{
+    list.clearStorage();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class T, int SizeMin>
+inline Foam::label Foam::PtrDynList<T, SizeMin>::capacity() const