From a7030ee97e1af924c66a33c5f0bb98da8e33d99a Mon Sep 17 00:00:00 2001
From: Will Bainbridge <http://cfd.direct>
Date: Fri, 4 Feb 2022 12:16:18 +0000
Subject: [PATCH] CompactListList: Removed unnecessary templating and create
 unallocated base

---
 .../CompactListList/Test-CompactListList.C    |   8 +-
 .../Lists/CompactListList/CompactListList.C   | 167 ++++--------
 .../Lists/CompactListList/CompactListList.H   | 130 ++-------
 .../Lists/CompactListList/CompactListListI.H  | 247 +++++-------------
 .../Lists/CompactListList/CompactListListIO.C |  39 ++-
 .../Lists/UCompactListList/UCompactListList.C |  65 +++++
 .../Lists/UCompactListList/UCompactListList.H | 179 +++++++++++++
 .../UCompactListList/UCompactListListI.H      | 221 ++++++++++++++++
 .../UCompactListList/UCompactListListIO.C     |  44 ++++
 .../fvMeshDistribute/fvMeshDistribute.C       |   6 +-
 .../polyTopoChange/polyTopoChange.H           |   8 +-
 .../ORourkeCollision/ORourkeCollision.C       |   4 +-
 .../decompositionMethod/decompositionMethod.C |  16 +-
 .../multiLevelDecomp/multiLevelDecomp.C       |   4 +-
 .../CuthillMcKeeRenumber.C                    |   4 +-
 .../renumberMethod/renumberMethod.C           |   6 +-
 .../springRenumber/springRenumber.C           |   4 +-
 17 files changed, 690 insertions(+), 462 deletions(-)
 create mode 100644 src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.C
 create mode 100644 src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.H
 create mode 100644 src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListI.H
 create mode 100644 src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListIO.C

diff --git a/applications/test/CompactListList/Test-CompactListList.C b/applications/test/CompactListList/Test-CompactListList.C
index 9912758235..a2e19e6300 100644
--- a/applications/test/CompactListList/Test-CompactListList.C
+++ b/applications/test/CompactListList/Test-CompactListList.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -88,7 +88,7 @@ int main(int argc, char *argv[])
     cll2(2, 3) = 999;
     Info<< "cll2(2, 3) = " << cll2(2, 3) << nl << endl;
 
-    Info<< "cll2 as List<List<label >> " << cll2()
+    Info<< "cll2 as List<List<label >> " << cll2.list()
         << endl;
 
     cll2.setSize(3);
@@ -144,10 +144,10 @@ int main(int argc, char *argv[])
         fcs[0] = face(labelList(1, 111));
         fcs[1] = face(labelList(2, 222));
 
-        CompactListList<label, face> compactFcs(fcs);
+        CompactListList<label> compactFcs(fcs);
         Info<< "compactFcs:" << compactFcs << endl;
 
-        faceList fcs2 = compactFcs();
+        faceList fcs2 = compactFcs.list<face>();
         Info<< "fcs2:" << fcs2 << endl;
     }
 
diff --git a/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C b/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
index b2091901cd..6c12a7d1f8 100644
--- a/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
+++ b/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,11 +27,13 @@ License
 
 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
-template<class T, class Container>
-Foam::CompactListList<T, Container>::CompactListList(const List<Container>& ll)
+template<class T>
+template<class Container>
+Foam::CompactListList<T>::CompactListList(const List<Container>& ll)
 :
-    size_(ll.size()),
-    offsets_(ll.size()+1)
+    UCompactListList<T>(),
+    offsets_(ll.size() + 1),
+    m_()
 {
     label sumSize = 0;
     offsets_[0] = 0;
@@ -46,46 +48,26 @@ Foam::CompactListList<T, Container>::CompactListList(const List<Container>& ll)
     label k = 0;
     forAll(ll, i)
     {
-        const Container& lli = ll[i];
-
-        forAll(lli, j)
+        forAll(ll[i], j)
         {
-            m_[k++] = lli[j];
+            m_[k++] = ll[i][j];
         }
     }
+
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
 }
 
 
-template<class T, class Container>
-Foam::CompactListList<T, Container>::CompactListList
-(
-    const labelUList& rowSizes
-)
-:
-    size_(rowSizes.size()),
-    offsets_(rowSizes.size()+1)
-{
-    label sumSize = 0;
-    offsets_[0] = 0;
-    forAll(rowSizes, i)
-    {
-        sumSize += rowSizes[i];
-        offsets_[i+1] = sumSize;
-    }
-
-    m_.setSize(sumSize);
-}
-
-
-template<class T, class Container>
-Foam::CompactListList<T, Container>::CompactListList
+template<class T>
+Foam::CompactListList<T>::CompactListList
 (
     const labelUList& rowSizes,
     const T& t
 )
 :
-    size_(rowSizes.size()),
-    offsets_(rowSizes.size()+1)
+    UCompactListList<T>(),
+    offsets_(rowSizes.size() + 1),
+    m_()
 {
     label sumSize = 0;
     offsets_[0] = 0;
@@ -96,48 +78,28 @@ Foam::CompactListList<T, Container>::CompactListList
     }
 
     m_.setSize(sumSize, t);
+
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
 }
 
 
-template<class T, class Container>
-Foam::CompactListList<T, Container>::CompactListList
-(
-    CompactListList<T, Container>&& lst
-)
-{
-    transfer(lst);
-}
-
-
-template<class T, class Container>
-Foam::CompactListList<T, Container>::CompactListList
-(
-    CompactListList<T, Container>& lst,
-    bool reuse
-)
-:
-    size_(lst.size()),
-    offsets_(lst.offsets_, reuse),
-    m_(lst.m_, reuse)
-{}
-
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-template<class T, class Container>
-void Foam::CompactListList<T, Container>::setSize(const label mRows)
+template<class T>
+void Foam::CompactListList<T>::setSize(const label mRows)
 {
     if (mRows == 0)
     {
         clear();
     }
-    if (mRows < size())
+    if (mRows < this->size())
     {
-        size_ = mRows;
-        offsets_.setSize(mRows+1);
+        offsets_.setSize(mRows + 1);
         m_.setSize(offsets_[mRows]);
+
+        UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
     }
-    else if (mRows > size())
+    else if (mRows > this->size())
     {
         FatalErrorInFunction
             << "Cannot be used to extend the list from " << offsets_.size()
@@ -148,38 +110,39 @@ void Foam::CompactListList<T, Container>::setSize(const label mRows)
 }
 
 
-template<class T, class Container>
-void Foam::CompactListList<T, Container>::setSize
+template<class T>
+void Foam::CompactListList<T>::setSize
 (
     const label mRows,
     const label nData
 )
 {
-    size_ = mRows;
-    offsets_.setSize(mRows+1);
+    offsets_.setSize(mRows + 1);
     m_.setSize(nData);
+
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
 }
 
 
-template<class T, class Container>
-void Foam::CompactListList<T, Container>::setSize
+template<class T>
+void Foam::CompactListList<T>::setSize
 (
     const label mRows,
     const label nData,
     const T& t
 )
 {
-    size_ = mRows;
-    offsets_.setSize(mRows+1);
+    offsets_.setSize(mRows + 1);
     m_.setSize(nData, t);
+
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
 }
 
 
-template<class T, class Container>
-void Foam::CompactListList<T, Container>::setSize(const labelUList& rowSizes)
+template<class T>
+void Foam::CompactListList<T>::setSize(const labelUList& rowSizes)
 {
-    size_ = rowSizes.size();
-    offsets_.setSize(rowSizes.size()+1);
+    offsets_.setSize(rowSizes.size() + 1);
 
     label sumSize = 0;
     offsets_[0] = 0;
@@ -190,62 +153,30 @@ void Foam::CompactListList<T, Container>::setSize(const labelUList& rowSizes)
     }
 
     m_.setSize(sumSize);
+
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
 }
 
 
-template<class T, class Container>
-Foam::labelList Foam::CompactListList<T, Container>::sizes() const
+template<class T>
+void Foam::CompactListList<T>::clear()
 {
-    labelList rowSizes(size());
-
-    if (rowSizes.size() > 0)
-    {
-        forAll(rowSizes, i)
-        {
-            rowSizes[i] = offsets_[i+1] - offsets_[i];
-        }
-    }
-    return rowSizes;
-}
-
-
-template<class T, class Container>
-void Foam::CompactListList<T, Container>::clear()
-{
-    size_ = 0;
-    offsets_.clear();
+    offsets_ = List<label>(1, 0);
     m_.clear();
+
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
 }
 
 
-template<class T, class Container>
-void Foam::CompactListList<T, Container>::transfer
-(
-    CompactListList<T, Container>& a
-)
+template<class T>
+void Foam::CompactListList<T>::transfer(CompactListList<T>& a)
 {
-    size_ = a.size_;
     offsets_.transfer(a.offsets_);
     m_.transfer(a.m_);
 
-    a.size_ = 0;
-}
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
 
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-template<class T, class Container>
-Foam::List<Container> Foam::CompactListList<T, Container>::operator()()
-const
-{
-    List<Container> ll(size());
-
-    forAll(ll, i)
-    {
-        ll[i] = Container(operator[](i));
-    }
-
-    return ll;
+    a.clear();
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.H b/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.H
index aad1c35c22..3a4a0573a1 100644
--- a/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.H
+++ b/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -36,9 +36,6 @@ Description
 
     Storage is allocated on free-store during construction.
 
-    As a special case a null-constructed CompactListList has an empty
-    offsets_ (instead of size 1).
-
 SourceFiles
     CompactListList.C
     CompactListListI.H
@@ -49,7 +46,7 @@ SourceFiles
 #ifndef CompactListList_H
 #define CompactListList_H
 
-#include "labelList.H"
+#include "UCompactListList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -58,31 +55,22 @@ namespace Foam
 
 // Forward declaration of friend functions and operators
 
-template<class T, class Container> class CompactListList;
+template<class T> class CompactListList;
 
-template<class T, class Container> Istream& operator>>
-(
-    Istream&,
-    CompactListList<T, Container>&
-);
-template<class T, class Container> Ostream& operator<<
-(
-    Ostream&,
-    const CompactListList<T, Container>&
-);
+template<class T> Istream& operator>>(Istream&, CompactListList<T>&);
 
 
 /*---------------------------------------------------------------------------*\
                        Class CompactListList Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class T, class Container = List<T>>
+template<class T>
 class CompactListList
+:
+    public UCompactListList<T>
 {
     // Private Data
 
-        label size_;
-
         //- Offset table
         List<label> offsets_;
 
@@ -95,7 +83,7 @@ public:
     // Static Member Functions
 
         //- Return a null CompactListList
-        inline static const CompactListList<T, Container>& null();
+        inline static const CompactListList<T>& null();
 
 
     // Constructors
@@ -103,59 +91,35 @@ public:
         //- Null constructor.
         inline CompactListList();
 
+        //- Construct from components
+        inline CompactListList(const UList<label>& offsets, const UList<T>& m);
+
+        //- Construct as copy or re-use as specified.
+        inline CompactListList(CompactListList<T>&, bool reuse);
+
         //- Move constructor
-        CompactListList(CompactListList<T, Container>&&);
-
-        //- Construct by converting given List<List<T>>
-        explicit CompactListList(const List<Container>&);
-
-        //- Construct given size of offset table (number of rows)
-        //  and number of data.
-        inline CompactListList(const label mRows, const label nData);
+        inline CompactListList(CompactListList<T>&&);
 
         //- Construct given size of offset table (number of rows),
         //  the number of data and a value for all elements.
         inline CompactListList(const label mRows, const label nData, const T&);
 
-        //- Construct given list of row-sizes.
-        explicit CompactListList(const labelUList& rowSizes);
+        //- Construct by converting given List<Container>
+        template<class Container>
+        CompactListList(const List<Container>&);
 
-        //- Construct given list of row-sizes
+        //- Construct given list of row-sizes and a value for all elements
         CompactListList(const labelUList& rowSizes, const T&);
 
-        //- Construct as copy or re-use as specified.
-        CompactListList(CompactListList<T, Container>&, bool reuse);
-
         //- Construct from Istream.
         CompactListList(Istream&);
 
         //- Clone
-        inline autoPtr<CompactListList<T, Container>> clone() const;
+        inline autoPtr<CompactListList<T>> clone() const;
 
 
     // Member Functions
 
-        // Access
-
-            //- Return the primary size, i.e. the number of rows
-            inline label size() const;
-
-            //- Return true if the number of rows is zero
-            inline bool empty() const;
-
-            //- Return the offset table (= size()+1)
-            inline const List<label>& offsets() const;
-
-            //- Return non-const access to the offset table
-            inline List<label>& offsets();
-
-            //- Return the packed matrix of data
-            inline const List<T>& m() const;
-
-            //- Return non-const access to the packed matrix of data
-            inline List<T>& m();
-
-
         // Edit
 
             //- Reset size of CompactListList.
@@ -187,65 +151,23 @@ public:
             //- Clear the CompactListList, i.e. set sizes to zero.
             void clear();
 
-            //- Return sizes (to be used e.g. for construction)
-            labelList sizes() const;
-
             //- Transfer the contents of the argument CompactListList
             //  into this CompactListList and annul the argument list.
-            void transfer(CompactListList<T, Container>&);
+            void transfer(CompactListList<T>&);
 
 
-        // Other
-
-            //- Return index into m
-            inline label index(const label row, const label col) const;
-
-            //- Get row for index into m.
-            inline label whichRow(const label index) const;
-
-            //- Get column index (j) given above row
-            inline label whichColumn(const label row, const label index) const;
-
-
-    // Member Operators
-
-        //- Return subscript-checked row as UList.
-        inline UList<T> operator[](const label i);
-
-        //- Return const subscript-checked row as UList.
-        inline const UList<T> operator[](const label i) const;
-
-        //- Return subscript-checked element.
-        inline T& operator()(const label i, const label j);
-
-        //- Return const subscript-checked element.
-        inline const T& operator()(const label i, const label j) const;
-
-        //- Return as List<Container>
-        List<Container> operator()() const;
-
-        //- Move assignment operator
-        inline void operator=(CompactListList<T, Container>&&);
-
-        //- Assignment of all entries to the given value
-        inline void operator=(const T&);
+        //- Disallow shallowCopy
+        void shallowCopy(const UCompactListList<T>&) = delete;
 
 
     // Istream operator
 
         //- Read CompactListList from Istream, discarding contents
         //  of existing CompactListList.
-        friend Istream& operator>> <T, Container>
+        friend Istream& operator>> <T>
         (
             Istream&,
-            CompactListList<T, Container>&
-        );
-
-        // Write CompactListList to Ostream.
-        friend Ostream& operator<< <T, Container>
-        (
-            Ostream&,
-            const CompactListList<T, Container>&
+            CompactListList<T>&
         );
 };
 
@@ -256,7 +178,7 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-    #include "CompactListListI.H"
+#include "CompactListListI.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H b/src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H
index 263c9b3d90..5c52e00009 100644
--- a/src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H
+++ b/src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,156 +23,99 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include "CompactListList.H"
 #include "ListOps.H"
-#include "SubList.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class T, class Container>
-inline Foam::CompactListList<T, Container>::CompactListList()
+template<class T>
+inline Foam::CompactListList<T>::CompactListList()
 :
-    size_(0)
-{}
+    UCompactListList<T>(),
+    offsets_(1, 0),
+    m_()
+{
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
+}
 
 
-template<class T, class Container>
-inline Foam::CompactListList<T, Container>::CompactListList
+template<class T>
+inline Foam::CompactListList<T>::CompactListList
 (
-    const label mRows,
-    const label nData
+    const UList<label>& offsets,
+    const UList<T>& m
 )
 :
-    size_(mRows),
-    offsets_(mRows+1, 0),
-    m_(nData)
+    UCompactListList<T>(offsets, m),
+    offsets_(offsets),
+    m_(m)
 {}
 
 
-template<class T, class Container>
-inline Foam::CompactListList<T, Container>::CompactListList
+template<class T>
+Foam::CompactListList<T>::CompactListList(CompactListList<T>& lst, bool reuse)
+:
+    UCompactListList<T>(),
+    offsets_(lst.offsets_, reuse),
+    m_(lst.m_, reuse)
+{
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
+}
+
+
+template<class T>
+Foam::CompactListList<T>::CompactListList(CompactListList<T>&& lst)
+{
+    transfer(lst);
+}
+
+
+template<class T>
+inline Foam::CompactListList<T>::CompactListList
 (
     const label mRows,
     const label nData,
     const T& t
 )
 :
-    size_(mRows),
-    offsets_(mRows+1, 0),
+    UCompactListList<T>(),
+    offsets_(mRows + 1, 0),
     m_(nData, t)
-{}
-
-
-template<class T, class Container>
-inline Foam::autoPtr<Foam::CompactListList<T, Container>>
-Foam::CompactListList<T, Container>::clone() const
 {
-    return autoPtr<CompactListList<T, Container>>
+    UCompactListList<T>::shallowCopy(UCompactListList<T>(offsets_, m_));
+}
+
+
+template<class T>
+inline Foam::autoPtr<Foam::CompactListList<T>>
+Foam::CompactListList<T>::clone() const
+{
+    return autoPtr<CompactListList<T>>
     (
-        new CompactListList<T, Container>(*this)
+        new CompactListList<T>(*this)
     );
 }
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-template<class T, class Container>
-inline const Foam::CompactListList<T, Container>&
-Foam::CompactListList<T, Container>::null()
+template<class T>
+inline const Foam::CompactListList<T>&
+Foam::CompactListList<T>::null()
 {
-    return NullObjectRef<CompactListList<T, Container>>();
+    return NullObjectRef<CompactListList<T>>();
 }
 
 
-template<class T, class Container>
-inline Foam::label Foam::CompactListList<T, Container>::size() const
-{
-    return size_;
-}
-
-
-template<class T, class Container>
-inline bool Foam::CompactListList<T, Container>::empty() const
-{
-    return !size_;
-}
-
-
-template<class T, class Container>
-inline const Foam::List<Foam::label>&
-Foam::CompactListList<T, Container>::offsets() const
-{
-    return offsets_;
-}
-
-
-template<class T, class Container>
-inline Foam::List<Foam::label>& Foam::CompactListList<T, Container>::offsets()
-{
-    return offsets_;
-}
-
-
-template<class T, class Container>
-inline const Foam::List<T>& Foam::CompactListList<T, Container>::m()
-const
-{
-    return m_;
-}
-
-
-template<class T, class Container>
-inline Foam::List<T>& Foam::CompactListList<T, Container>::m()
-{
-    return m_;
-}
-
-
-template<class T, class Container>
-inline Foam::label Foam::CompactListList<T, Container>::index
-(
-    const label i,
-    const label j
-) const
-{
-    return offsets_[i] + j;
-}
-
-
-template<class T, class Container>
-inline Foam::label Foam::CompactListList<T, Container>::whichRow(const label i)
-const
-{
-    if (i < 0 || i >= m_.size())
-    {
-        FatalErrorInFunction
-            << "Index " << i << " outside 0.." << m_.size()
-            << abort(FatalError);
-    }
-
-    return findLower(offsets_, i+1);
-}
-
-
-template<class T, class Container>
-inline Foam::label Foam::CompactListList<T, Container>::whichColumn
-(
-    const label row,
-    const label i
-) const
-{
-    return i - index(row, 0);
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList<T, Container>::resize(const label mRows)
+template<class T>
+inline void Foam::CompactListList<T>::resize(const label mRows)
 {
     this->setSize(mRows);
 }
 
 
-template<class T, class Container>
-inline void Foam::CompactListList<T, Container>::resize
+template<class T>
+inline void Foam::CompactListList<T>::resize
 (
     const label mRows,
     const label nData
@@ -182,8 +125,8 @@ inline void Foam::CompactListList<T, Container>::resize
 }
 
 
-template<class T, class Container>
-inline void Foam::CompactListList<T, Container>::resize
+template<class T>
+inline void Foam::CompactListList<T>::resize
 (
     const label mRows,
     const label nData,
@@ -194,8 +137,8 @@ inline void Foam::CompactListList<T, Container>::resize
 }
 
 
-template<class T, class Container>
-inline void Foam::CompactListList<T, Container>::resize
+template<class T>
+inline void Foam::CompactListList<T>::resize
 (
     const labelUList& rowSizes
 )
@@ -204,72 +147,4 @@ inline void Foam::CompactListList<T, Container>::resize
 }
 
 
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-template<class T, class Container>
-inline Foam::UList<T> Foam::CompactListList<T, Container>::operator[]
-(
-    const label i
-)
-{
-    label start = offsets_[i];
-    return UList<T>(m_.begin() + start, offsets_[i+1] - start);
-}
-
-
-template<class T, class Container>
-inline const Foam::UList<T>
-Foam::CompactListList<T, Container>::operator[]
-(
-    const label i
-) const
-{
-    label start = offsets_[i];
-    return UList<T>
-    (
-        const_cast<T*>(m_.begin() + start),
-        offsets_[i+1] - start
-    );
-}
-
-
-template<class T, class Container>
-inline T& Foam::CompactListList<T, Container>::operator()
-(
-    const label i,
-    const label j
-)
-{
-    return m_[index(i, j)];
-}
-
-
-template<class T, class Container>
-inline const T& Foam::CompactListList<T, Container>::operator()
-(
-    const label i,
-    const label j
-) const
-{
-    return m_[index(i, j)];
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList<T, Container>::operator=
-(
-    CompactListList<T, Container>&& cll
-)
-{
-    transfer(cll);
-}
-
-
-template<class T, class Container>
-inline void Foam::CompactListList<T, Container>::operator=(const T& t)
-{
-    m_ = t;
-}
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/CompactListList/CompactListListIO.C b/src/OpenFOAM/containers/Lists/CompactListList/CompactListListIO.C
index e97436e3ef..bcf8bb5e0a 100644
--- a/src/OpenFOAM/containers/Lists/CompactListList/CompactListListIO.C
+++ b/src/OpenFOAM/containers/Lists/CompactListList/CompactListListIO.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,8 +28,8 @@ License
 
 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
-template<class T, class Container>
-Foam::CompactListList<T, Container>::CompactListList(Istream& is)
+template<class T>
+Foam::CompactListList<T>::CompactListList(Istream& is)
 {
     operator>>(is, *this);
 }
@@ -37,33 +37,24 @@ Foam::CompactListList<T, Container>::CompactListList(Istream& is)
 
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
-template<class T, class Container>
-Foam::Istream& Foam::operator>>(Istream& is, CompactListList<T, Container>& lst)
+template<class T>
+Foam::Istream& Foam::operator>>(Istream& is, CompactListList<T>& lst)
 {
     is  >> lst.offsets_ >> lst.m_;
-    // Note: empty list gets output as two empty lists
-    if (lst.offsets_.size() == 0)
+
+    // An empty compact list list gets output as two empty lists
+    if (lst.offsets_.empty())
     {
-        lst.size_ = 0;
-    }
-    else
-    {
-        lst.size_ = lst.offsets_.size()-1;
+        lst.clear();
     }
+
+    lst.UCompactListList<T>::shallowCopy
+    (
+        UCompactListList<T>(lst.offsets_, lst.m_)
+    );
+
     return is;
 }
 
 
-template<class T, class Container>
-Foam::Ostream& Foam::operator<<
-(
-    Ostream& os,
-    const CompactListList<T, Container>& lst
-)
-{
-    os  << lst.offsets_ << lst.m_;
-    return os;
-}
-
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.C b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.C
new file mode 100644
index 0000000000..0917602695
--- /dev/null
+++ b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.C
@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     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 "UCompactListList.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class T>
+Foam::labelList Foam::UCompactListList<T>::sizes() const
+{
+    labelList rowSizes(size());
+
+    if (rowSizes.size() > 0)
+    {
+        forAll(rowSizes, i)
+        {
+            rowSizes[i] = offsets_[i+1] - offsets_[i];
+        }
+    }
+    return rowSizes;
+}
+
+
+template<class T>
+template<class Container>
+Foam::List<Container> Foam::UCompactListList<T>::list() const
+{
+    List<Container> ll(size());
+
+    forAll(ll, i)
+    {
+        ll[i] = Container(operator[](i));
+    }
+
+    return ll;
+}
+
+
+// * * * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * //
+
+#include "UCompactListListIO.C"
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.H b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.H
new file mode 100644
index 0000000000..e8b4ac19c3
--- /dev/null
+++ b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListList.H
@@ -0,0 +1,179 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     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::UCompactListList
+
+Description
+    Unallocated base class of CompactListList
+
+SourceFiles
+    UCompactListList.C
+    UCompactListListI.H
+    UCompactListListIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef UCompactListList_H
+#define UCompactListList_H
+
+#include "labelList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of friend functions and operators
+
+template<class T> class UCompactListList;
+
+template<class T> Ostream& operator<<(Ostream&, const UCompactListList<T>&);
+
+/*---------------------------------------------------------------------------*\
+                       Class UCompactListList Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class T>
+class UCompactListList
+{
+    // Private Data
+
+        //- Offset table
+        UList<label> offsets_;
+
+        //- Packed matrix of data
+        UList<T> m_;
+
+
+public:
+
+    // Static Member Functions
+
+        //- Return a null UCompactListList
+        inline static const UCompactListList<T>& null();
+
+
+    // Constructors
+
+        //- Null constructor.
+        inline UCompactListList();
+
+        //- Construct from components
+        inline UCompactListList(const UList<label>& offsets, const UList<T>& m);
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return the primary size, i.e. the number of rows
+            inline label size() const;
+
+            //- Return true if the number of rows is zero
+            inline bool empty() const;
+
+            //- Return the offset table (= size()+1)
+            inline const UList<label>& offsets() const;
+
+            //- Return non-const access to the offset table
+            inline UList<label>& offsets();
+
+            //- Return the packed matrix of data
+            inline const UList<T>& m() const;
+
+            //- Return non-const access to the packed matrix of data
+            inline UList<T>& m();
+
+
+        //- Copy the ULists, but not the underlying data
+        inline void shallowCopy(const UCompactListList<T>&);
+
+        //- Copy the underlying data
+        inline void deepCopy(const UCompactListList<T>&);
+
+        //- Return index into m
+        inline label index(const label row, const label col) const;
+
+        //- Get row for index into m.
+        inline label whichRow(const label index) const;
+
+        //- Get column index (j) given above row
+        inline label whichColumn(const label row, const label index) const;
+
+        //- Return sizes (to be used e.g. for construction)
+        labelList sizes() const;
+
+        //- Convert to List<Container>
+        template<class Container = List<T>>
+        List<Container> list() const;
+
+
+    // Member Operators
+
+        //- Return subscript-checked row as UList.
+        inline UList<T> operator[](const label i);
+
+        //- Return const subscript-checked row as UList.
+        inline const UList<T> operator[](const label i) const;
+
+        //- Return subscript-checked element.
+        inline T& operator()(const label i, const label j);
+
+        //- Return const subscript-checked element.
+        inline const T& operator()(const label i, const label j) const;
+
+        //- Assignment of all entries to the given value
+        inline void operator=(const T&);
+
+
+    // Istream operator
+
+        // Write UCompactListList to Ostream.
+        friend Ostream& operator<< <T>
+        (
+            Ostream&,
+            const UCompactListList<T>&
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "UCompactListListI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "UCompactListList.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListI.H b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListI.H
new file mode 100644
index 0000000000..544f0edc9c
--- /dev/null
+++ b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListI.H
@@ -0,0 +1,221 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     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 "UCompactListList.H"
+#include "ListOps.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class T>
+inline Foam::UCompactListList<T>::UCompactListList()
+:
+    offsets_(nullptr, 1),
+    m_()
+{}
+
+
+template<class T>
+inline Foam::UCompactListList<T>::UCompactListList
+(
+    const UList<label>& offsets,
+    const UList<T>& m
+)
+:
+    offsets_(offsets),
+    m_(m)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class T>
+inline const Foam::UCompactListList<T>&
+Foam::UCompactListList<T>::null()
+{
+    return NullObjectRef<UCompactListList<T>>();
+}
+
+
+template<class T>
+inline Foam::label Foam::UCompactListList<T>::size() const
+{
+    return offsets_.size() - 1;
+}
+
+
+template<class T>
+inline bool Foam::UCompactListList<T>::empty() const
+{
+    return !size();
+}
+
+
+template<class T>
+inline const Foam::UList<Foam::label>&
+Foam::UCompactListList<T>::offsets() const
+{
+    return offsets_;
+}
+
+
+template<class T>
+inline Foam::UList<Foam::label>& Foam::UCompactListList<T>::offsets()
+{
+    return offsets_;
+}
+
+
+template<class T>
+inline const Foam::UList<T>& Foam::UCompactListList<T>::m()
+const
+{
+    return m_;
+}
+
+
+template<class T>
+inline Foam::UList<T>& Foam::UCompactListList<T>::m()
+{
+    return m_;
+}
+
+
+template<class T>
+inline void Foam::UCompactListList<T>::shallowCopy
+(
+    const UCompactListList<T>& l
+)
+{
+    offsets_.shallowCopy(l.offsets_);
+    m_.shallowCopy(l.m_);
+}
+
+
+template<class T>
+inline void Foam::UCompactListList<T>::deepCopy
+(
+    const UCompactListList<T>& l
+)
+{
+    offsets_.deepCopy(l.offsets_);
+    m_.deepCopy(l.m_);
+}
+
+
+template<class T>
+inline Foam::label Foam::UCompactListList<T>::index
+(
+    const label i,
+    const label j
+) const
+{
+    return offsets_[i] + j;
+}
+
+
+template<class T>
+inline Foam::label Foam::UCompactListList<T>::whichRow(const label i) const
+{
+    if (i < 0 || i >= m_.size())
+    {
+        FatalErrorInFunction
+            << "Index " << i << " outside 0.." << m_.size()
+            << abort(FatalError);
+    }
+
+    return findLower(offsets_, i+1);
+}
+
+
+template<class T>
+inline Foam::label Foam::UCompactListList<T>::whichColumn
+(
+    const label row,
+    const label i
+) const
+{
+    return i - index(row, 0);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class T>
+inline Foam::UList<T> Foam::UCompactListList<T>::operator[]
+(
+    const label i
+)
+{
+    label start = offsets_[i];
+    return UList<T>(m_.begin() + start, offsets_[i+1] - start);
+}
+
+
+template<class T>
+inline const Foam::UList<T>
+Foam::UCompactListList<T>::operator[]
+(
+    const label i
+) const
+{
+    label start = offsets_[i];
+    return UList<T>
+    (
+        const_cast<T*>(m_.begin() + start),
+        offsets_[i+1] - start
+    );
+}
+
+
+template<class T>
+inline T& Foam::UCompactListList<T>::operator()
+(
+    const label i,
+    const label j
+)
+{
+    return m_[index(i, j)];
+}
+
+
+template<class T>
+inline const T& Foam::UCompactListList<T>::operator()
+(
+    const label i,
+    const label j
+) const
+{
+    return m_[index(i, j)];
+}
+
+
+template<class T>
+inline void Foam::UCompactListList<T>::operator=(const T& t)
+{
+    m_ = t;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListIO.C b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListIO.C
new file mode 100644
index 0000000000..009d541a52
--- /dev/null
+++ b/src/OpenFOAM/containers/Lists/UCompactListList/UCompactListListIO.C
@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     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 "UCompactListList.H"
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+template<class T>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const UCompactListList<T>& lst
+)
+{
+    // An empty compact list list gets output as two empty lists
+    os << (lst.size() ? lst.offsets_ : labelUList()) << lst.m_;
+
+    return os;
+}
+
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
index 7da47764a3..620a4eae92 100644
--- a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
+++ b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -1594,7 +1594,7 @@ void Foam::fvMeshDistribute::sendMesh
     // Send
     toDomain
         << mesh.points()
-        << CompactListList<label, face>(mesh.faces())
+        << CompactListList<label>(mesh.faces())
         << mesh.faceOwner()
         << mesh.faceNeighbour()
         << mesh.boundaryMesh()
@@ -1641,7 +1641,7 @@ Foam::autoPtr<Foam::fvMesh> Foam::fvMeshDistribute::receiveMesh
 )
 {
     pointField domainPoints(fromNbr);
-    faceList domainFaces = CompactListList<label, face>(fromNbr)();
+    faceList domainFaces = CompactListList<label>(fromNbr).list<face>();
     labelList domainAllOwner(fromNbr);
     labelList domainAllNeighbour(fromNbr);
     PtrList<entry> patchEntries(fromNbr);
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.H
index f334a19156..4dfe21946a 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -89,7 +89,7 @@ class dictionary;
 class topoAction;
 class objectMap;
 class IOobject;
-template<class T, class Container> class CompactListList;
+template<class T> class CompactListList;
 
 /*---------------------------------------------------------------------------*\
                        Class polyTopoChange Declaration
@@ -272,13 +272,13 @@ class polyTopoChange
         void makeCellCells
         (
             const label nActiveFaces,
-            CompactListList<label, labelList>& cellCells
+            CompactListList<label>& cellCells
         ) const;
 
         //- Cell ordering (bandCompression). Returns number of remaining cells.
         label getCellOrder
         (
-            const CompactListList<label, labelList>&,
+            const CompactListList<label>&,
             labelList&
         ) const;
 
diff --git a/src/lagrangian/parcel/submodels/Spray/StochasticCollision/ORourkeCollision/ORourkeCollision.C b/src/lagrangian/parcel/submodels/Spray/StochasticCollision/ORourkeCollision/ORourkeCollision.C
index 7f164c2144..4fcd7ea439 100644
--- a/src/lagrangian/parcel/submodels/Spray/StochasticCollision/ORourkeCollision/ORourkeCollision.C
+++ b/src/lagrangian/parcel/submodels/Spray/StochasticCollision/ORourkeCollision/ORourkeCollision.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -51,7 +51,7 @@ void Foam::ORourkeCollision<CloudType>::collide
     }
 
     // Initialise the sizes of the lists of parcels in each cell
-    CompactListList<parcelType*> pInCell(occupancy);
+    CompactListList<parcelType*> pInCell(occupancy, nullptr);
 
     // Reset the occupancy to use as a counter
     occupancy = 0;
diff --git a/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C b/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
index 4ecbbb0761..e7cc6a5e61 100644
--- a/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
+++ b/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -224,7 +224,7 @@ Foam::labelList Foam::decompositionMethod::decompose
     (
         decompose
         (
-            coarseCellCells(),
+            coarseCellCells.list(),
             coarsePoints,
             coarseWeights
         )
@@ -382,7 +382,7 @@ void Foam::decompositionMethod::calcCellCells
 
     nFacesPerCell = 0;
 
-    labelList& m = cellCells.m();
+    labelUList& m = cellCells.m();
     const labelList& offsets = cellCells.offsets();
 
     // For internal faces is just offsetted owner and neighbour
@@ -459,7 +459,7 @@ void Foam::decompositionMethod::calcCellCells
         cellCells.offsets()[celli+1] = newIndex;
     }
 
-    cellCells.m().setSize(newIndex);
+    cellCells.setSize(cellCells.size(), newIndex);
 }
 
 
@@ -574,8 +574,8 @@ void Foam::decompositionMethod::calcCellCells
 
     nFacesPerCell = 0;
 
-    labelList& m = cellCells.m();
-    scalarList& w = cellCellWeights.m();
+    labelUList& m = cellCells.m();
+    scalarUList& w = cellCellWeights.m();
     const labelList& offsets = cellCells.offsets();
 
     // For internal faces is just offsetted owner and neighbour
@@ -662,8 +662,8 @@ void Foam::decompositionMethod::calcCellCells
         cellCellWeights.offsets()[cellI+1] = newIndex;
     }
 
-    cellCells.m().setSize(newIndex);
-    cellCellWeights.m().setSize(newIndex);
+    cellCells.setSize(cellCells.size(), newIndex);
+    cellCellWeights.setSize(cellCells.size(), newIndex);
 }
 
 
diff --git a/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C b/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C
index f9bac82c9d..693545cdfe 100644
--- a/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C
+++ b/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -386,7 +386,7 @@ Foam::labelList Foam::multiLevelDecomp::decompose
 
     decompose
     (
-        cellCells(),
+        cellCells.list(),
         cc,
         cWeights,
         cellMap,      // map back to original cells
diff --git a/src/renumber/renumberMethods/CuthillMcKeeRenumber/CuthillMcKeeRenumber.C b/src/renumber/renumberMethods/CuthillMcKeeRenumber/CuthillMcKeeRenumber.C
index 152480ab95..903ff7c39a 100644
--- a/src/renumber/renumberMethods/CuthillMcKeeRenumber/CuthillMcKeeRenumber.C
+++ b/src/renumber/renumberMethods/CuthillMcKeeRenumber/CuthillMcKeeRenumber.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -76,7 +76,7 @@ Foam::labelList Foam::CuthillMcKeeRenumber::renumber
         cellCells
     );
 
-    labelList orderedToOld = bandCompression(cellCells());
+    labelList orderedToOld = bandCompression(cellCells.list());
 
     if (reverse_)
     {
diff --git a/src/renumber/renumberMethods/renumberMethod/renumberMethod.C b/src/renumber/renumberMethods/renumberMethod/renumberMethod.C
index 3d48b8d6f8..e7cd74e42d 100644
--- a/src/renumber/renumberMethods/renumberMethod/renumberMethod.C
+++ b/src/renumber/renumberMethods/renumberMethod/renumberMethod.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2021 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -90,7 +90,7 @@ Foam::labelList Foam::renumberMethod::renumber
     );
 
     // Renumber based on agglomerated points
-    return renumber(cellCells(), points);
+    return renumber(cellCells.list(), points);
 }
 
 
@@ -128,7 +128,7 @@ Foam::labelList Foam::renumberMethod::renumber
     (
         renumber
         (
-            coarseCellCells(),
+            coarseCellCells.list(),
             coarsePoints
         )
     );
diff --git a/src/renumber/renumberMethods/springRenumber/springRenumber.C b/src/renumber/renumberMethods/springRenumber/springRenumber.C
index d8fcf6d05e..cc6972bb5f 100644
--- a/src/renumber/renumberMethods/springRenumber/springRenumber.C
+++ b/src/renumber/renumberMethods/springRenumber/springRenumber.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -72,7 +72,7 @@ Foam::labelList Foam::springRenumber::renumber
         cellCells
     );
 
-    return renumber(cellCells(), points);
+    return renumber(cellCells.list(), points);
 }