ENH: new bitSet class and improved PackedList class (closes #751)

- The bitSet class replaces the old PackedBoolList class.
  The redesign provides better block-wise access and reduced method
  calls. This helps both in cases where the bitSet may be relatively
  sparse, and in cases where advantage of contiguous operations can be
  made. This makes it easier to work with a bitSet as top-level object.

  In addition to the previously available count() method to determine
  if a bitSet is being used, now have simpler queries:

    - all()  - true if all bits in the addressable range are empty
    - any()  - true if any bits are set at all.
    - none() - true if no bits are set.

  These are faster than count() and allow early termination.

  The new test() method tests the value of a single bit position and
  returns a bool without any ambiguity caused by the return type
  (like the get() method), nor the const/non-const access (like
  operator[] has). The name corresponds to what std::bitset uses.

  The new find_first(), find_last(), find_next() methods provide a faster
  means of searching for bits that are set.

  This can be especially useful when using a bitSet to control an
  conditional:

  OLD (with macro):

      forAll(selected, celli)
      {
          if (selected[celli])
          {
              sumVol += mesh_.cellVolumes()[celli];
          }
      }

  NEW (with const_iterator):

      for (const label celli : selected)
      {
          sumVol += mesh_.cellVolumes()[celli];
      }

      or manually

      for
      (
          label celli = selected.find_first();
          celli != -1;
          celli = selected.find_next()
      )
      {
          sumVol += mesh_.cellVolumes()[celli];
      }

- When marking up contiguous parts of a bitset, an interval can be
  represented more efficiently as a labelRange of start/size.
  For example,

  OLD:

      if (isA<processorPolyPatch>(pp))
      {
          forAll(pp, i)
          {
              ignoreFaces.set(i);
          }
      }

  NEW:

      if (isA<processorPolyPatch>(pp))
      {
          ignoreFaces.set(pp.range());
      }

applications/solvers/combustion/PDRFoam/PDRFoamAutoRefine.C

@@ -122,7 +122,7 @@ int main(int argc, char *argv[])
             fvc::makeAbsolute(phi, rho, U);
 
             // Test : disable refinement for some cells
-            PackedBoolList& protectedCell =
+            bitSet& protectedCell =
                 refCast<dynamicRefineFvMesh>(mesh).protectedCell();
 
             if (protectedCell.empty())

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/interpolatedFaces.H

@@ -2,8 +2,8 @@
 interpolationCellPoint<vector> UInterpolator(HbyA);
 
 // Determine faces on outside of interpolated cells
-PackedBoolList isOwnerInterpolatedFace(mesh.nInternalFaces());
+bitSet isOwnerInterpolatedFace(mesh.nInternalFaces());
-PackedBoolList isNeiInterpolatedFace(mesh.nInternalFaces());
+bitSet isNeiInterpolatedFace(mesh.nInternalFaces());
 
 // Determine donor cells
 labelListList donorCell(mesh.nInternalFaces());
@@ -175,11 +175,11 @@ surfaceVectorField faceNormals(mesh.Sf()/mesh.magSf());
 forAll(isNeiInterpolatedFace, faceI)
 {
     label cellId = -1;
-    if (isNeiInterpolatedFace[faceI])
+    if (isNeiInterpolatedFace.test(faceI))
     {
         cellId = mesh.faceNeighbour()[faceI];
     }
-    else if (isOwnerInterpolatedFace[faceI])
+    else if (isOwnerInterpolatedFace.test(faceI))
     {
         cellId = mesh.faceOwner()[faceI];
     }

applications/test/List/Test-List.C

@@ -474,7 +474,7 @@ int main(int argc, char *argv[])
         }
 
         {
-            PackedBoolList select = HashSetOps::bitset(locations);
+            bitSet select = HashSetOps::bitset(locations);
             auto output = ListOps::createWithValue<label>
             (
                 30,
@@ -482,8 +482,8 @@ int main(int argc, char *argv[])
                 100,
                 -1  // default value
             );
-            Info<< "with PackedBoolList: " << flatOutput(output)
+            Info<< "with bitSet: " << flatOutput(output)
-                << " selector: " << flatOutput(select.used()) << nl;
+                << " selector: " << flatOutput(select.toc()) << nl;
         }
 
         {
@@ -516,7 +516,7 @@ int main(int argc, char *argv[])
         }
 
         {
-            PackedBoolList select = HashSetOps::bitset(locations);
+            bitSet select = HashSetOps::bitset(locations);
             auto output = ListOps::createWithValue<label>
             (
                 30,
@@ -524,7 +524,7 @@ int main(int argc, char *argv[])
                 100,
                 -1  // default value
             );
-            Info<< "with PackedBoolList: " << flatOutput(output)
+            Info<< "with bitSet: " << flatOutput(output)
                 << " selector: " << flatOutput(HashSetOps::used(select))
                 << nl;
         }

applications/test/ListOps/Test-ListOps.C

@@ -145,7 +145,7 @@ int main(int argc, char *argv[])
     Info<<"Test reorder - oldToNew:" << nl
         << flatOutput(oldToNew) << nl << nl;
 
-    PackedBoolList bitset
+    bitSet bitset
     (
         ListOps::createWithValue<bool>
         (

applications/test/PackedList/Test-PackedList.C

@@ -32,7 +32,7 @@ Description
 #include "IOobject.H"
 #include "IOstreams.H"
 #include "IFstream.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include <climits>
 
 
@@ -131,7 +131,7 @@ int main(int argc, char *argv[])
         IFstream ifs(srcFile);
         List<label> rawLst(ifs);
 
-        PackedBoolList packLst(rawLst);
+        bitSet packLst(rawLst);
 
         Info<< "size: " << packLst.size() << nl;
 

applications/test/PackedList1/Test-PackedList1.C

@@ -28,61 +28,100 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "uLabel.H"
+#include "labelRange.H"
+#include "bitSet.H"
+#include "FlatOutput.H"
 #include "IOstreams.H"
-#include "PackedBoolList.H"
 
 using namespace Foam;
 
+template<unsigned Width>
+inline Ostream& report
+(
+    const PackedList<Width>& list,
+    bool showBits = false,
+    bool debugOutput = false
+)
+{
+    Info<< list.info();
+    if (showBits)
+    {
+        list.printBits(Info, debugOutput) << nl;
+    }
+
+    return Info;
+}
+
+
+inline Ostream& report
+(
+    const bitSet& bitset,
+    bool showBits = false,
+    bool debugOutput = false
+)
+{
+    Info<< bitset.info();
+    Info<< "all:" << bitset.all()
+        << " any:" << bitset.any()
+        << " none:" << bitset.none() << nl;
+
+    if (showBits)
+    {
+        bitset.printBits(Info, debugOutput) << nl;
+    }
+
+    return Info;
+}
+
+// BitOps::printBits((Info<< list1.info()), true) << nl;
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
 int main(int argc, char *argv[])
 {
-    Info<< "PackedList max_bits() = " << PackedList<>::max_bits() << nl;
-
     Info<< "\ntest allocation with value\n";
     PackedList<3> list1(5,1);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest assign uniform value\n";
     list1 = 3;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest assign uniform value (with overflow)\n";
     list1 = -1;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest zero\n";
     list1 = 0;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest set() with default argument (max_value)\n";
     list1.set(1);
     list1.set(3);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest unset() with in-range and out-of-range\n";
     list1.unset(3);
     list1.unset(100000);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest assign between references\n";
     list1[2] = 3;
     list1[4] = list1[2];
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest assign between references, with chaining\n";
     list1[0] = 1;
     list1[4] = 1;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest assign between references, with chaining and auto-vivify\n";
     list1[1] = 2;
     list1[8] = 2;
     list1[10] = 2;
     list1[14] = 2;
-    list1.printInfo(Info, true);
+    report(list1);
-
 
     Info<< "\ntest operator== between references\n";
     if (list1[1] == list1[8])
@@ -106,7 +145,9 @@ int main(int argc, char *argv[])
     {
         const PackedList<3>& constLst = list1;
         Info<< "\ntest operator[] const with out-of-range index\n";
-        constLst.printInfo(Info, true);
+
+        report(constLst);
+
         if (constLst[20])
         {
             Info<< "[20] is true (unexpected)\n";
@@ -116,7 +157,7 @@ int main(int argc, char *argv[])
             Info<< "[20] is false (expected) list size should be unchanged "
                 << "(const)\n";
         }
-        constLst.printInfo(Info, true);
+        report(constLst);
 
         Info<< "\ntest operator[] non-const with out-of-range index\n";
         if (list1[20])
@@ -128,7 +169,8 @@ int main(int argc, char *argv[])
             Info<< "[20] is false (expected) but list was resized?? "
                 << "(non-const)\n";
         }
-        list1.printInfo(Info, true);
+
+        report(list1);
     }
 
 
@@ -137,94 +179,94 @@ int main(int argc, char *argv[])
     {
         Info<< "[20] is false, as expected\n";
     }
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest resize with value (without reallocation)\n";
-    list1.resize(8, list1.max_value());
+    list1.resize(8, list1.max_value);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest flip() function\n";
     list1.flip();
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\nre-flip()\n";
     list1.flip();
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest set() function\n";
     list1.set(1, 5);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest assign bool\n";
     list1 = false;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest assign bool\n";
     list1 = true;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest resize without value (with reallocation)\n";
     list1.resize(12);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest resize with value (with reallocation)\n";
-    list1.resize(25, list1.max_value());
+    list1.resize(25, list1.max_value);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest resize smaller (should not touch allocation)\n";
     list1.resize(8);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest append() operation\n";
     list1.append(2);
     list1.append(3);
     list1.append(4);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest reserve() operation\n";
     list1.reserve(32);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest shrink() operation\n";
     list1.shrink();
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest setCapacity() operation\n";
     list1.setCapacity(15);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest setCapacity() operation\n";
     list1.setCapacity(100);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest operator[] assignment\n";
     list1[16] = 5;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest operator[] assignment with auto-vivify\n";
-    list1[36] = list1.max_value();
+    list1[36] = list1.max_value;
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest setCapacity smaller\n";
     list1.setCapacity(24);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest resize much smaller\n";
     list1.resize(150);
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest trim\n";
     list1.trim();
-    list1.printInfo(Info, true);
+    report(list1);
 
-    // add in some misc values
+    // Add in some misc values
     list1[31] = 1;
     list1[32] = 2;
     list1[33] = 3;
 
     Info<< "\ntest get() method\n";
     Info<< "get(10):" << list1.get(10) << " and list[10]:" << list1[10] << "\n";
-    list1.printInfo(Info, true);
+    report(list1);
 
     Info<< "\ntest operator[] auto-vivify\n";
     Info<< "size:" << list1.size() << "\n";
@@ -234,33 +276,34 @@ int main(int argc, char *argv[])
     Info<< "list[45]:" << val << "\n";
     Info<< "size after read:" << list1.size() << "\n";
 
-    list1[45] = list1.max_value();
+    list1[45] = list1.max_value;
     Info<< "size after write:" << list1.size() << "\n";
     Info<< "list[45]:" << list1[45] << "\n";
     list1[49] = list1[100];
-    list1.printInfo(Info, true);
+    report(list1);
 
 
     Info<< "\ntest copy constructor + append\n";
     PackedList<3> list2(list1);
     list2.append(4);
     Info<< "source list:\n";
-    list1.printInfo(Info, true);
+    report(list1);
+
     Info<< "destination list:\n";
-    list2.printInfo(Info, true);
+    report(list2);
 
     Info<< "\ntest pattern that fills all bits\n";
     PackedList<4> list3(8, 8);
 
     label pos = list3.size() - 1;
 
-    list3[pos--] = list3.max_value();
+    list3[pos--] = list3.max_value;
     list3[pos--] = 0;
-    list3[pos--] = list3.max_value();
+    list3[pos--] = list3.max_value;
-    list3.printInfo(Info, true);
+    report(list3);
 
     Info<< "removed final value: " << list3.remove() << endl;
-    list3.printInfo(Info, true);
+    report(list3);
 
     Info<<"list: " << list3 << endl;
 
@@ -289,18 +332,117 @@ int main(int argc, char *argv[])
     }
 
 
-    PackedBoolList listb(list4);
+    bitSet listb(list4);
 
     Info<< "copied from bool list " << endl;
-    listb.printInfo(Info, true);
+    // report(listb);
 
     {
-        labelList indices = listb.used();
+        labelList indices = listb.toc();
 
         Info<< "indices: " << indices << endl;
     }
 
 
+    Info<< nl
+        << "resizing: " << nl;
+    {
+        PackedList<1> list1(81, 1);
+        PackedList<3> list3(27, 5); // ie, 101
+
+        Info<< "initial" << nl; report(list1, true);
+        Info<< "initial" << nl; report(list3, true);
+
+        list1.resize(118, 1);
+        list3.resize(37, 3);
+        Info<< "extend with val" << nl; report(list1, true);
+        Info<< "extend with val" << nl; report(list3, true);
+
+        list1.resize(90, 0);
+        list3.resize(30, 4);
+
+        Info<< "contract with val" << nl; report(list1, true);
+        Info<< "contract with val" << nl; report(list3, true);
+    }
+
+    {
+        bitSet bits(45);
+
+        Info<< "bits" << nl; report(bits, true);
+
+        bits = true;
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.unset(35);
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.resize(39);
+        Info<< "bits" << nl; report(bits, true);
+
+        Info<< "values:" << flatOutput(bits.values()) << nl;
+        Info<< "used:" << flatOutput(bits.toc()) << nl;
+
+        bits.unset(labelRange(-15, 8));
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.set(labelRange(-15, 100));
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.set(labelRange(-15, 100));
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.set(labelRange(150, 15));
+        Info<< "bits" << nl; report(bits, true);
+        bits.set(labelRange(0, 5));
+        Info<< "bits" << nl; report(bits, true);
+
+
+        bits.reset();
+        bits.resize(50);
+
+        Info<< "bits" << nl; report(bits, true);
+        bits.set(labelRange(4, 8));
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.set(labelRange(30, 35));
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.set(labelRange(80, 12));
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.unset(labelRange(35, 16));
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.unset(labelRange(0, 50));
+        bits.resize(100000);
+        bits.set(labelRange(30, 6));
+        bits[33] = false;
+
+        Info<<"used: " << flatOutput(bits.toc()) << endl;
+
+        Info<<"first: " << bits.find_first() << endl;
+        Info<<"next: " << bits.find_next(29) << endl;
+        Info<<"next: " << bits.find_next(30) << endl;
+        Info<<"next: " << bits.find_next(31) << endl;
+
+        Info<<"next: " << bits.find_next(31) << endl;
+
+        bits.set(labelRange(80, 10));
+        bits.resize(100);
+        Info<< "bits" << nl; report(bits, true);
+
+        bits.set(labelRange(125, 10));
+
+        Info<<"next: " << bits.find_next(64) << endl;
+        Info<<"used: " << flatOutput(bits.toc()) << endl;
+
+        for (const auto pos : bits)
+        {
+            Info<<"have: " << pos << nl;
+        }
+
+    }
+
     Info<< "\n\nDone.\n";
 
     return 0;

applications/test/PackedList2/Test-PackedList2.C

@@ -29,7 +29,7 @@ Description
 
 #include "argList.H"
 #include "boolList.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "HashSet.H"
 #include "cpuTime.H"
 #include <vector>
@@ -63,7 +63,7 @@ int main(int argc, char *argv[])
 
     unsigned long sum = 0;
 
-    PackedBoolList packed(n, 1);
+    bitSet packed(n, true);
     boolList unpacked(n, true);
 
     #ifdef TEST_STD_BOOLLIST

applications/test/PackedList3/Make/files

@@ -1,3 +0,0 @@
-Test-PackedList3.C
-
-EXE = $(FOAM_USER_APPBIN)/Test-PackedList3

applications/test/PackedList4/Make/files

@@ -1,3 +0,0 @@
-Test-PackedList4.C
-
-EXE = $(FOAM_USER_APPBIN)/Test-PackedList4

applications/test/PackedList4/Test-PackedList4.C

@@ -1,168 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 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/>.
-
-Application
-
-Description
-
-\*---------------------------------------------------------------------------*/
-
-#include "uLabel.H"
-#include "boolList.H"
-#include "DynamicList.H"
-#include "IOstreams.H"
-#include "PackedBoolList.H"
-#include "ITstream.H"
-#include "StringStream.H"
-#include "FlatOutput.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-//  Main program:
-
-int main(int argc, char *argv[])
-{
-    PackedBoolList list1(20);
-    // set every third one on
-    forAll(list1, i)
-    {
-        list1[i] = !(i % 3);
-    }
-
-    Info<< "\nalternating bit pattern\n";
-    list1.printInfo(Info, true);
-
-    PackedBoolList list2(list1);
-    list2.flip();
-
-    Info<< "\nflipped bit pattern\n";
-    list2.printBits(Info);
-
-    // set every other on
-    forAll(list2, i)
-    {
-        list2[i] = !(i % 2);
-    }
-
-    Info<< "\nalternating bit pattern\n";
-    list2.printBits(Info);
-
-    list2.resize(28, false);
-    list2.resize(34, true);
-    list2.resize(40, false);
-    for (label i=0; i < 4; ++i)
-    {
-        list2[i] = true;
-    }
-
-    Info<< "\nresized with false, 6 true + 6 false, bottom 4 bits true\n";
-    list2.printInfo(Info, true);
-
-    labelList list2Labels = list2.used();
-
-    PackedBoolList list4
-    (
-        ITstream
-        (
-            "input",
-            "(1 n 1 n 1 n 1 1 off 0 0 f f 0 y yes y true y false on t)"
-        )()
-    );
-
-    Info<< "\ntest Istream constructor\n";
-
-    list4.printInfo(Info, true);
-    Info<< list4 << " indices: " << list4.used() << nl;
-
-    Info<< "\nassign from labelList\n";
-    list4.clear();
-    list4.setMany(labelList{0, 1, 2, 3, 12, 13, 14, 19, 20, 21});
-
-    list4.printInfo(Info, true);
-    Info<< list4 << " indices: " << list4.used() << nl;
-
-    // Not yet:
-    // PackedBoolList list5{0, 1, 2, 3, 12, 13, 14, 19, 20, 21};
-    // list5.printInfo(Info, true);
-    // Info<< list5 << " indices: " << list5.used() << nl;
-
-    Info<< "\nassign from indices\n";
-    list4.read
-    (
-        IStringStream
-        (
-            "{0 1 2 3 12 13 14 19 20 21}"
-        )()
-    );
-
-
-    list4.printInfo(Info, true);
-    Info<< list4 << " indices: " << list4.used() << nl;
-
-    boolList bools(list4.size());
-    forAll(list4, i)
-    {
-        bools[i] = list4[i];
-    }
-
-    Info<< "boolList: " << bools << nl;
-
-    // check roundabout assignments
-    PackedList<2> pl2
-    (
-        IStringStream
-        (
-            "{(0 3)(1 3)(2 3)(3 3)(12 3)(13 3)(14 3)(19 3)(20 3)(21 3)}"
-        )()
-    );
-
-    Info<< "roundabout assignment: " << pl2 << nl;
-
-    list4.clear();
-    forAll(pl2, i)
-    {
-        list4[i] = pl2[i];
-    }
-
-    list4.writeList(Info, -1) << nl; // indexed output
-
-    list4.writeEntry("PackedBoolList", Info);
-
-    // Construct from labelUList, labelUIndList
-    {
-        DynamicList<label> indices({10, 50, 300});
-
-        Info<< "set: " << flatOutput(indices) << endl;
-
-        PackedBoolList bools1(indices);
-
-        Info<< "used: " << bools1.size() << " "
-            << flatOutput(bools1.used()) << endl;
-    }
-
-    return 0;
-}
-
-
-// ************************************************************************* //

applications/test/PatchTools/Test-PatchTools.C

@@ -218,7 +218,7 @@ int main(int argc, char *argv[])
 
         labelList patchEdges;
         labelList coupledEdges;
-        PackedBoolList sameEdgeOrientation;
+        bitSet sameEdgeOrientation;
         PatchTools::matchEdges
         (
             pp,

applications/test/bitSet1/Make/files

@@ -0,0 +1,3 @@
+Test-bitSet1.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-bitSet1

applications/test/bitSet1/Test-bitSet1.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,50 +22,60 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Application
+    Test-bitSet1
 
 Description
+    Test bitSet functionality
 
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
+#include "boolList.H"
+#include "bitSet.H"
+#include "HashSet.H"
 #include "cpuTime.H"
-#include "PackedBoolList.H"
+#include <vector>
+#include <unordered_set>
 
 using namespace Foam;
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+inline Ostream& report
+(
+    const bitSet& bitset,
+    bool showBits = false,
+    bool debugOutput = false
+)
+{
+    Info<< "size=" << bitset.size() << "/" << bitset.capacity()
+        << " count=" << bitset.count()
+        << " all:" << bitset.all()
+        << " any:" << bitset.any()
+        << " none:" << bitset.none() << nl;
 
+    Info<< "values: " << flatOutput(bitset) << nl;
+    if (showBits)
+    {
+        bitset.printBits(Info, debugOutput) << nl;
+    }
+
+    return Info;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 // Main program:
 
 int main(int argc, char *argv[])
 {
-    const label nLoop = 5;
+    bitSet set1(100);
-    const label n = 100000000;
-    // const label nReport = 1000000;
 
-    cpuTime timer;
+    Info<<"bitSet(label): "; report(set1, true);
 
-    // test inserts
+    bitSet set2(100, { -1, 10, 25, 45});
-    PackedBoolList packed;
+    Info<<"bitSet(label, labels): "; report(set2, true);
-    for (label iloop = 0; iloop < nLoop; ++iloop)
-    {
-        for (label i = 0; i < n; ++i)
-        {
-            // if ((i % nReport) == 0 && i)
-            // {
-            //     Info<< "." << flush;
-            // }
-            packed[i] = 1;
-            // Make compiler do something else too
-            packed[i/2] = 0;
-        }
-    }
-    Info<< nl
-        << "insert test: " << nLoop << "*" << n << " elements in "
-        << timer.cpuTimeIncrement() << " s\n\n";
 
-    Info << "\nEnd\n" << endl;
+    Info<< "End\n" << endl;
 
     return 0;
 }

applications/test/bitSet2/Make/files

@@ -0,0 +1,3 @@
+Test-bitSet2.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-bitSet2

applications/test/bitSet2/Test-bitSet2.C

@@ -0,0 +1,311 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Application
+    Test-bitSet2
+
+Description
+    Test bitSet functionality
+
+\*---------------------------------------------------------------------------*/
+
+#include "uLabel.H"
+#include "boolList.H"
+#include "DynamicList.H"
+#include "IOstreams.H"
+#include "ITstream.H"
+#include "StringStream.H"
+#include "bitSet.H"
+#include "FlatOutput.H"
+
+using namespace Foam;
+
+inline Ostream& report
+(
+    const bitSet& bitset,
+    bool showBits = false,
+    bool debugOutput = false
+)
+{
+    Info<< "size=" << bitset.size() << "/" << bitset.capacity()
+        << " count=" << bitset.count()
+        << " all:" << bitset.all()
+        << " any:" << bitset.any()
+        << " none:" << bitset.none() << nl;
+
+    Info<< "values: " << flatOutput(bitset) << nl;
+    if (showBits)
+    {
+        bitset.printBits(Info, debugOutput) << nl;
+    }
+
+    return Info;
+}
+
+
+template<class UIntType>
+std::string toString(UIntType value, char off='.', char on='1')
+{
+    std::string str(std::numeric_limits<UIntType>::digits, off);
+
+    unsigned n = 0;
+
+    // Starting from most significant bit - makes for easy reading.
+    for
+    (
+        unsigned test = (1u << (std::numeric_limits<UIntType>::digits-1));
+        test;
+        test >>= 1u
+    )
+    {
+        str[n++] = ((value & test) ? on : off);
+    }
+
+    return str;
+}
+
+
+inline bool compare
+(
+    const bitSet& bitset,
+    const std::string& expected
+)
+{
+    const List<unsigned int>& store = bitset.storage();
+
+    std::string has;
+
+    for (label blocki=0; blocki < bitset.nBlocks(); ++blocki)
+    {
+        has += toString(store[blocki]);
+    }
+
+    if (has == expected)
+    {
+        Info<< "pass: " << has << nl;
+        return true;
+    }
+
+    Info<< "fail:   " << has << nl;
+    Info<< "expect: " << expected << nl;
+
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    bitSet list1(22);
+    // Set every third one on
+    forAll(list1, i)
+    {
+        list1[i] = !(i % 3);
+    }
+    Info<< "\nalternating bit pattern\n";
+    compare(list1, "..........1..1..1..1..1..1..1..1");
+
+    list1.unset(labelRange(13, 20));  // In range
+
+    Info<< "\nafter clear [13,..]\n";
+    compare(list1, "...................1..1..1..1..1");
+
+    report(list1, true);
+
+    list1.unset(labelRange(40, 20));  // out of range
+    Info<< "\nafter clear [40,..]\n";
+    compare(list1, "...................1..1..1..1..1");
+
+    report(list1, true);
+
+
+    Info<< "first: " << list1.find_first()
+        << " last: " << list1.find_last() << endl;
+
+    Info<< "iterate through:";
+    for (const label idx : list1)
+    {
+        Info<<" " << idx;
+    }
+    Info<< nl;
+
+    Info<< "\nalternating bit pattern\n";
+    report(list1, true);
+
+    bitSet list2 = ~list1;
+
+    Info<< "\nflipped bit pattern\n";
+    report(list2, true);
+
+    // set every other on
+    forAll(list2, i)
+    {
+        list2[i] = !(i % 2);
+    }
+
+    Info<< "\nstarting pattern\n";
+    report(list2, true);
+
+    list2.resize(28, false);
+    list2.resize(34, true);
+    list2.resize(40, false);
+    for (label i=0; i < 4; ++i)
+    {
+        list2[i] = true;
+    }
+
+    Info<< "\nresized with false, [28,34) true + 6 false, bottom 4 bits true\n";
+
+    compare
+    (
+        list2,
+        "1111.......1.1.1.1.1.1.1.1.11111"
+        "..............................11"
+    );
+
+
+    report(list2, true);
+
+    labelList list2Labels = list2.toc();
+
+    Info<< "\noperator|\n";
+
+    list1.printBits(Info);
+    list2.printBits(Info);
+    Info<< "==\n";
+    (list1 | list2).printBits(Info);
+
+    Info<< "\noperator& : does trim\n";
+    report((list1 & list2), true);
+
+    Info<< "\noperator^\n";
+    report((list1 ^ list2), true);
+
+    Info<< "\noperator|=\n";
+    {
+        bitSet list3 = list1;
+        report((list3 |= list2), true);
+    }
+
+    Info<< "\noperator&=\n";
+    {
+        bitSet list3 = list1;
+        report((list3 &= list2), true);
+    }
+
+    Info<< "\noperator^=\n";
+    {
+        bitSet list3 = list1;
+        report((list3 ^= list2), true);
+    }
+
+    Info<< "\noperator-=\n";
+    {
+        bitSet list3 = list1;
+        report((list3 -= list2), true);
+    }
+
+    bitSet list4
+    (
+        ITstream
+        (
+            "input",
+            "(1 n 1 n 1 n 1 1 off 0 0 f f 0 y yes y true y false on t)"
+        )()
+    );
+
+    Info<< "\ntest Istream constructor\n";
+
+    report(list4, true);
+
+    Info<< "\nclear/assign from labelList\n";
+    list4.clear();
+    list4.setMany(labelList{0, 1, 2, 3, 12, 13, 14, 19, 20, 21});
+
+    report(list4, true);
+
+    // Not yet:
+    // bitSet list5{0, 1, 2, 3, 12, 13, 14, 19, 20, 21};
+    // list5.printInfo(Info, true);
+    // Info<< list5 << " indices: " << list5.toc() << nl;
+
+    Info<< "\nassign from indices\n";
+    list4.read
+    (
+        IStringStream
+        (
+            "{0 1 2 3 12 13 14 19 20 21}"
+        )()
+    );
+
+    report(list4, true);
+    compare(list4, "..........111....111........1111");
+
+    list4.set(labelRange(28, 6));  // extends size
+
+    Info<<"extended\n";
+    compare
+    (
+        list4,
+        "1111......111....111........1111"
+        "..............................11"
+    );
+
+    list4.set(labelRange(40, 6));  // extends size
+    Info<<"extended\n";
+    compare
+    (
+        list4,
+        "1111......111....111........1111"
+        "..................111111......11"
+    );
+
+    list4.unset(labelRange(14, 19));
+    Info<<"cleared [14,33)\n";
+    compare
+    (
+        list4,
+        "..................11........1111"
+        "..................111111......1."
+    );
+
+
+    // Construct from labelUList, labelUIndList
+    {
+        DynamicList<label> indices({10, 50, 300});
+
+        Info<< "set: " << flatOutput(indices) << endl;
+
+        bitSet bools1(indices);
+
+        Info<< "used: " << bools1.size() << " "
+            << flatOutput(bools1.toc()) << endl;
+    }
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/bitops/Test-bitops.C

@@ -27,6 +27,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "bool.H"
+#include "BitOps.H"
 #include "IOstreams.H"
 #include "stdFoam.H"
 
@@ -177,6 +178,15 @@ int main(int argc, char *argv[])
 
     printOffset<double>();
 
+
+    Info<<nl << "Test repeat_value" << nl << nl;
+
+    Info<< BitOps::bitInfo<unsigned>(BitOps::repeat_value<unsigned, 3>(1u))
+        << nl;
+
+    Info<< BitOps::bitInfo<unsigned>(BitOps::repeat_value<unsigned>(1u))
+        << nl;
+
     Info << "---\nEnd\n" << endl;
 
     return 0;

applications/test/limits/Make/files

@@ -0,0 +1,3 @@
+Test-limits.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-limits

applications/test/limits/Make/options

@@ -0,0 +1,2 @@
+/* EXE_INC = */
+/* EXE_LIBS = */

applications/test/machine-sizes/Test-machine-sizes.cpp

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,44 +22,24 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Description
-    Test the sizeof for basic types. Can be compiled and run without
+    Test the sizeof for basic types.
-    any OpenFOAM libraries.
+    Can be compiled and run without any OpenFOAM libraries.
+
+        g++ -std=c++11 -oTest-machine-sizes Test-machine-sizes.cpp
 
 \*---------------------------------------------------------------------------*/
 
 #include <cstdint>
 #include <climits>
 #include <cstdlib>
-#include <limits>
 #include <iostream>
 
-// Can also compile without OpenFOAM
-#ifdef WM_LABEL_SIZE
-    #include "IOstreams.H"
-#endif
-
 template<class T>
 void print(const char* msg)
 {
     std::cout<< msg << ' ' << sizeof(T) << '\n';
 }
 
-
-#ifdef WM_LABEL_SIZE
-template<class T>
-void printMax(const char* msg)
-{
-    std::cout<< msg << ' ' << sizeof(T)
-        << " max "
-        << std::numeric_limits<T>::max() << '\n';
-
-    Foam::Info<< msg << ' ' << sizeof(T)
-        << " max "
-        << long(std::numeric_limits<T>::max()) << '\n';
-}
-#endif
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
 
@@ -67,42 +47,16 @@ int main(int argc, char *argv[])
 {
     std::cout<<"machine sizes\n---\n\n";
 
-    print<mode_t>("mode_t");
     print<short>("short");
     print<int>("int");
     print<long>("long");
     print<long long>("long long");
-    print<unsigned short>("ushort");
-    print<unsigned int>("uint");
-    print<unsigned long>("ulong");
-    print<unsigned long long>("ulong-long");
-    print<int16_t>("int16");
-    print<int32_t>("int32");
-    print<int64_t>("int64");
-    print<uint16_t>("uint16");
-    print<uint32_t>("uint32");
-    print<uint64_t>("uint64");
     print<float>("float");
     print<double>("double");
+    print<long double>("long double");
     print<std::string>("std::string");
     print<std::string::size_type>("std::string::size_type");
 
-    #ifdef WM_LABEL_SIZE
-    std::cout<<"\nmax values\n---\n\n";
-
-    printMax<mode_t>("mode_t");
-    Foam::Info<< "mode_t 0777: " << mode_t(0777) << '\n';
-
-    printMax<short>("short");
-    printMax<int>("int");
-    printMax<long>("long");
-    printMax<unsigned short>("ushort");
-    printMax<unsigned int>("uint");
-    printMax<unsigned long>("ulong");
-    printMax<float>("float");
-    printMax<double>("double");
-    #endif
-
     std::cout << "\n---\nEnd\n\n";
 
     return 0;

applications/test/surfaceMeshConvert/Test-surfaceMeshConvert.C

@@ -48,10 +48,6 @@ Usage
 
       - \par -triSurface
         Use triSurface library for input/output
-
-      - \par -keyed
-        Use keyedSurface for input/output
-
 Note
     The filename extensions are used to determine the file format type.
 
@@ -64,7 +60,6 @@ Note
 #include "surfMesh.H"
 #include "surfFields.H"
 #include "surfPointFields.H"
-#include "PackedBoolList.H"
 
 #include "MeshedSurfaces.H"
 #include "ModifiableMeshedSurface.H"

applications/test/syncTools/Test-syncTools.C

@@ -406,13 +406,13 @@ void testPointSync(const polyMesh& mesh, Random& rndGen)
     {
         labelList nMasters(mesh.nPoints(), 0);
 
-        PackedBoolList isMasterPoint(syncTools::getMasterPoints(mesh));
+        bitSet isMasterPoint(syncTools::getMasterPoints(mesh));
 
         forAll(isMasterPoint, pointi)
         {
-            if (isMasterPoint[pointi])
+            if (isMasterPoint.test(pointi))
             {
-                nMasters[pointi] = 1;
+                nMasters.set(pointi);
             }
         }
 
@@ -482,13 +482,13 @@ void testEdgeSync(const polyMesh& mesh, Random& rndGen)
     {
         labelList nMasters(edges.size(), 0);
 
-        PackedBoolList isMasterEdge(syncTools::getMasterEdges(mesh));
+        bitSet isMasterEdge(syncTools::getMasterEdges(mesh));
 
         forAll(isMasterEdge, edgeI)
         {
-            if (isMasterEdge[edgeI])
+            if (isMasterEdge.test(edgeI))
             {
-                nMasters[edgeI] = 1;
+                nMasters.set(edgeI);
             }
         }
 
@@ -551,13 +551,13 @@ void testFaceSync(const polyMesh& mesh, Random& rndGen)
     {
         labelList nMasters(mesh.nFaces(), 0);
 
-        PackedBoolList isMasterFace(syncTools::getMasterFaces(mesh));
+        Bitset isMasterFace(syncTools::getMasterFaces(mesh));
 
         forAll(isMasterFace, facei)
         {
-            if (isMasterFace[facei])
+            if (isMasterFace.test(facei))
             {
-                nMasters[facei] = 1;
+                nMasters.set(facei);
             }
         }
 

applications/utilities/mesh/advanced/PDRMesh/PDRMesh.C

@@ -81,7 +81,7 @@ void modifyOrAddFace
     const label zoneID,
     const bool zoneFlip,
 
-    PackedBoolList& modifiedFace
+    bitSet& modifiedFace
 )
 {
     if (modifiedFace.set(facei))
@@ -338,7 +338,7 @@ void subsetTopoSets
         Info<< "Subsetting " << set.type() << " " << set.name() << endl;
 
         // Map the data
-        PackedBoolList isSet(set.maxSize(mesh));
+        bitSet isSet(set.maxSize(mesh));
         forAllConstIter(labelHashSet, set, iter)
         {
             isSet.set(iter.key());
@@ -374,7 +374,7 @@ void createCoupledBaffles
     fvMesh& mesh,
     const labelList& coupledWantedPatch,
     polyTopoChange& meshMod,
-    PackedBoolList& modifiedFace
+    bitSet& modifiedFace
 )
 {
     const faceZoneMesh& faceZones = mesh.faceZones();
@@ -442,7 +442,7 @@ void createCyclicCoupledBaffles
     const labelList& cyclicMasterPatch,
     const labelList& cyclicSlavePatch,
     polyTopoChange& meshMod,
-    PackedBoolList& modifiedFace
+    bitSet& modifiedFace
 )
 {
     const faceZoneMesh& faceZones = mesh.faceZones();
@@ -1119,7 +1119,7 @@ int main(int argc, char *argv[])
 
 
     // Whether first use of face (modify) or consecutive (add)
-    PackedBoolList modifiedFace(mesh.nFaces());
+    bitSet modifiedFace(mesh.nFaces());
 
     // Create coupled wall-side baffles
     createCoupledBaffles

applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C

@@ -366,7 +366,7 @@ void Foam::cellSplitter::setRefinement
 
 
     // Mark off affected face.
-    boolList faceUpToDate(mesh_.nFaces(), true);
+    bitSet faceUpToDate(mesh_.nFaces(), true);
 
     forAllConstIter(Map<point>, cellToMidPoint, iter)
     {
@@ -374,18 +374,15 @@ void Foam::cellSplitter::setRefinement
 
         const cell& cFaces = mesh_.cells()[celli];
 
-        forAll(cFaces, i)
+        faceUpToDate.unsetMany(cFaces);
-        {
-            label facei = cFaces[i];
-
-            faceUpToDate[facei] = false;
-        }
     }
 
     forAll(faceUpToDate, facei)
     {
-        if (!faceUpToDate[facei])
+        if (!faceUpToDate.test(facei))
         {
+            faceUpToDate.set(facei);
+
             const face& f = mesh_.faces()[facei];
 
             if (mesh_.isInternalFace(facei))
@@ -454,8 +451,6 @@ void Foam::cellSplitter::setRefinement
                     )
                 );
             }
-
-            faceUpToDate[facei] = true;
         }
     }
 }

applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C

@@ -579,7 +579,7 @@ int main(int argc, char *argv[])
 
         pointField newPoints(points);
 
-        PackedBoolList collapseEdge(mesh.nEdges());
+        bitSet collapseEdge(mesh.nEdges());
         Map<point> collapsePointToLocation(mesh.nPoints());
 
         // Get new positions and construct collapse network

applications/utilities/mesh/advanced/refineWallLayer/refineWallLayer.C

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016-2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2016-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -97,10 +97,10 @@ int main(int argc, char *argv[])
     label nPatchFaces = 0;
     label nPatchEdges = 0;
 
-    forAllConstIter(labelHashSet, patchSet, iter)
+    for (const label patchi : patchSet)
     {
-        nPatchFaces += mesh.boundaryMesh()[iter.key()].size();
+        nPatchFaces += mesh.boundaryMesh()[patchi].size();
-        nPatchEdges += mesh.boundaryMesh()[iter.key()].nEdges();
+        nPatchEdges += mesh.boundaryMesh()[patchi].nEdges();
     }
 
     // Construct from estimate for the number of cells to refine
@@ -111,15 +111,13 @@ int main(int argc, char *argv[])
     DynamicList<scalar> allCutEdgeWeights(nPatchEdges);
 
     // Find cells to refine
-    forAllConstIter(labelHashSet, patchSet, iter)
+    for (const label patchi : patchSet)
     {
-        const polyPatch& pp = mesh.boundaryMesh()[iter.key()];
+        const polyPatch& pp = mesh.boundaryMesh()[patchi];
         const labelList& meshPoints = pp.meshPoints();
 
-        forAll(meshPoints, pointi)
+        for (const label meshPointi : meshPoints)
         {
-            label meshPointi = meshPoints[pointi];
-
             const labelList& pCells = mesh.pointCells()[meshPointi];
 
             cutCells.insertMany(pCells);
@@ -139,49 +137,43 @@ int main(int argc, char *argv[])
             << cells.instance()/cells.local()/cells.name()
             << nl << endl;
 
-        forAllConstIter(cellSet, cells, iter)
+        for (const label celli : cells)
         {
-            cutCells.erase(iter.key());
+            cutCells.erase(celli);
         }
         Info<< "Removed from cells to cut all the ones not in set "
             << setName << nl << endl;
     }
 
     // Mark all mesh points on patch
-    boolList vertOnPatch(mesh.nPoints(), false);
+    bitSet vertOnPatch(mesh.nPoints());
 
-    forAllConstIter(labelHashSet, patchSet, iter)
+    for (const label patchi : patchSet)
     {
-        const polyPatch& pp = mesh.boundaryMesh()[iter.key()];
+        const polyPatch& pp = mesh.boundaryMesh()[patchi];
         const labelList& meshPoints = pp.meshPoints();
 
-        forAll(meshPoints, pointi)
+        vertOnPatch.setMany(meshPoints);
-        {
-            vertOnPatch[meshPoints[pointi]] = true;
-        }
     }
 
-    forAllConstIter(labelHashSet, patchSet, iter)
+    for (const label patchi : patchSet)
     {
-        const polyPatch& pp = mesh.boundaryMesh()[iter.key()];
+        const polyPatch& pp = mesh.boundaryMesh()[patchi];
         const labelList& meshPoints = pp.meshPoints();
 
-        forAll(meshPoints, pointi)
+        for (const label meshPointi : meshPoints)
         {
-            label meshPointi = meshPoints[pointi];
-
             const labelList& pEdges = mesh.pointEdges()[meshPointi];
 
-            forAll(pEdges, pEdgeI)
+            for (const label edgei : pEdges)
             {
-                const label edgeI = pEdges[pEdgeI];
+                const edge& e = mesh.edges()[edgei];
-                const edge& e = mesh.edges()[edgeI];
 
                 label otherPointi = e.otherVertex(meshPointi);
 
-                if (!vertOnPatch[otherPointi])
+                if (!vertOnPatch.test(otherPointi))
                 {
-                    allCutEdges.append(edgeI);
+                    allCutEdges.append(edgei);
 
                     if (e.start() == meshPointi)
                     {
@@ -214,7 +206,7 @@ int main(int argc, char *argv[])
     (
         mesh,
         cutCells.toc(),     // cells candidate for cutting
-        labelList(0),       // cut vertices
+        labelList(),        // cut vertices
         allCutEdges,        // cut edges
         cutEdgeWeights      // weight on cut edges
     );

applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L

@@ -869,7 +869,7 @@ int main(int argc, char *argv[])
     // Pre-filtering: flip "owner" boundary or wrong oriented internal
     // faces and move to neighbour
 
-    boolList fm(faces.size(), false);
+    bitSet fm(faces.size(), false);
     forAll(faces, facei)
     {
         if
@@ -878,7 +878,7 @@ int main(int argc, char *argv[])
          || (neighbour[facei] != -1 && owner[facei] > neighbour[facei])
         )
         {
-            fm[facei] = true;
+            fm.set(facei);
             if (!cubitFile)
             {
                 faces[facei].flip();
@@ -1279,7 +1279,7 @@ int main(int argc, char *argv[])
                     false,              // flipFaceFlux
                     -1,                 // patchID
                     faceZonei,          // zoneID
-                    fm[facei]           // zoneFlip
+                    fm.test(facei)      // zoneFlip
                 );
             }
 

applications/utilities/mesh/conversion/fluentMeshToFoam/fluentMeshToFoam.L

@@ -1620,14 +1620,14 @@ int main(int argc, char *argv[])
             labelList cls(end() - start() + 1);
 
             // Mark zone cells, used for finding faces
-            boolList zoneCell(pShapeMesh.nCells(), false);
+            bitSet zoneCell(pShapeMesh.nCells(), false);
 
             // shift cell indizes by 1
             label nr=0;
             for (label celli = (start() - 1); celli < end(); celli++)
             {
                 cls[nr]=celli;
-                zoneCell[celli] = true;
+                zoneCell.set(celli);
                 nr++;
             }
 
@@ -1646,7 +1646,7 @@ int main(int argc, char *argv[])
                 label own = pShapeMesh.faceOwner()[facei];
                 if (nei != -1)
                 {
-                    if (zoneCell[nei] && zoneCell[own])
+                    if (zoneCell.test(nei) && zoneCell.test(own))
                     {
                         zoneFaces.append(facei);
                     }
@@ -1669,7 +1669,7 @@ int main(int argc, char *argv[])
                 const labelList& faceCells = bPatches[pI].faceCells();
                 forAll(faceCells, fcI)
                 {
-                    if (zoneCell[faceCells[fcI] ])
+                    if (zoneCell.test(faceCells[fcI]))
                     {
                         boundaryZones[pI].append(name);
                         break;

applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C

@@ -890,7 +890,7 @@ int main(int argc, char *argv[])
         const edgeList& edges = mesh.edges();
         const pointField& points = mesh.points();
 
-        PackedBoolList collapseEdge(mesh.nEdges());
+        bitSet collapseEdge(mesh.nEdges());
         Map<point> collapsePointToLocation(mesh.nPoints());
 
         forAll(edges, edgeI)

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C

@@ -1268,7 +1268,7 @@ void extrudeGeometricProperties
     // Determine edge normals on original patch
     labelList patchEdges;
     labelList coupledEdges;
-    PackedBoolList sameEdgeOrientation;
+    bitSet sameEdgeOrientation;
     PatchTools::matchEdges
     (
         extrudePatch,
@@ -2160,7 +2160,7 @@ int main(int argc, char *argv[])
     labelListList extrudeEdgePatches(extrudePatch.nEdges());
 
     // Is edge a non-manifold edge
-    PackedBoolList nonManifoldEdge(extrudePatch.nEdges());
+    bitSet nonManifoldEdge(extrudePatch.nEdges());
 
     // Note: logic has to be same as in countExtrudePatches.
     forAll(edgeFaces, edgeI)

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshApp.C

@@ -256,7 +256,7 @@ int main(int argc, char *argv[])
         const boundBox& bb = mesh().bounds();
         const scalar mergeDim = 1e-4 * bb.minDim();
 
-        PackedBoolList collapseEdge(mesh().nEdges());
+        bitSet collapseEdge(mesh().nEdges());
         Map<point> collapsePointToLocation(mesh().nPoints());
 
         forAll(edges, edgeI)

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellShapeControl/controlMeshRefinement/controlMeshRefinement.C

@@ -321,7 +321,7 @@ void Foam::controlMeshRefinement::initialMeshPopulation
         sizes.clear();
         alignments.clear();
 
-        PackedBoolList keepVertex(vertices.size(), true);
+        bitSet keepVertex(vertices.size(), true);
 
         forAll(vertices, vI)
         {
@@ -496,7 +496,7 @@ void Foam::controlMeshRefinement::initialMeshPopulation
             }
         }
 
-        PackedBoolList keepVertex(vertices.size(), true);
+        bitSet keepVertex(vertices.size(), true);
 
         forAll(vertices, vI)
         {

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.C

@@ -1081,7 +1081,7 @@ void Foam::conformalVoronoiMesh::move()
         Zero
     );
 
-    PackedBoolList pointToBeRetained(number_of_vertices(), true);
+    bitSet pointToBeRetained(number_of_vertices(), true);
 
     DynamicList<Point> pointsToInsert(number_of_vertices());
 

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

@@ -47,7 +47,7 @@ SourceFiles
 #include "cellShapeControl.H"
 #include "cvControls.H"
 #include "DynamicList.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "Time.H"
 #include "polyMesh.H"
 #include "plane.H"
@@ -606,7 +606,7 @@ private:
             pointField& cellCentres,
             labelList& cellToDelaunayVertex,
             labelListList& patchToDelaunayVertex,
-            PackedBoolList& boundaryFacesToRemove
+            bitSet& boundaryFacesToRemove
         );
 
         void calcNeighbourCellCentres
@@ -760,7 +760,7 @@ private:
             wordList& patchNames,
             PtrList<dictionary>& patchDicts,
             labelListList& patchPointPairSlaves,
-            PackedBoolList& boundaryFacesToRemove,
+            bitSet& boundaryFacesToRemove,
             bool includeEmptyPatches = false
         ) const;
 
@@ -791,7 +791,7 @@ private:
             faceList& faces,
             labelList& owner,
             PtrList<dictionary>& patchDicts,
-            PackedBoolList& boundaryFacesToRemove,
+            bitSet& boundaryFacesToRemove,
             const List<DynamicList<face>>& patchFaces,
             const List<DynamicList<label>>& patchOwners,
             const List<DynamicList<bool>>& indirectPatchFace
@@ -997,7 +997,7 @@ public:
                 const wordList& patchNames,
                 const PtrList<dictionary>& patchDicts,
                 const pointField& cellCentres,
-                PackedBoolList& boundaryFacesToRemove
+                bitSet& boundaryFacesToRemove
             ) const;
 
             //- Calculate and write a field of the target cell size,

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C

@@ -47,7 +47,7 @@ void Foam::conformalVoronoiMesh::calcDualMesh
     pointField& cellCentres,
     labelList& cellToDelaunayVertex,
     labelListList& patchToDelaunayVertex,
-    PackedBoolList& boundaryFacesToRemove
+    bitSet& boundaryFacesToRemove
 )
 {
     timeCheck("Start calcDualMesh");
@@ -277,7 +277,7 @@ void Foam::conformalVoronoiMesh::calcTetMesh
 
     sortFaces(faces, owner, neighbour);
 
-//    PackedBoolList boundaryFacesToRemove;
+//    bitSet boundaryFacesToRemove;
 //    List<DynamicList<bool>> indirectPatchFace;
 //
 //    addPatches
@@ -703,7 +703,7 @@ Foam::conformalVoronoiMesh::createPolyMeshFromPoints
     PtrList<dictionary> patchDicts;
     pointField cellCentres;
     labelListList patchToDelaunayVertex;
-    PackedBoolList boundaryFacesToRemove;
+    bitSet boundaryFacesToRemove;
 
     timeCheck("Start of checkPolyMeshQuality");
 
@@ -1103,7 +1103,7 @@ Foam::labelHashSet Foam::conformalVoronoiMesh::checkPolyMeshQuality
     }
 
 
-    PackedBoolList ptToBeLimited(pts.size(), false);
+    bitSet ptToBeLimited(pts.size(), false);
 
     forAllConstIter(labelHashSet, wrongFaces, iter)
     {
@@ -1704,7 +1704,7 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
     wordList& patchNames,
     PtrList<dictionary>& patchDicts,
     labelListList& patchPointPairSlaves,
-    PackedBoolList& boundaryFacesToRemove,
+    bitSet& boundaryFacesToRemove,
     bool includeEmptyPatches
 ) const
 {
@@ -2486,7 +2486,7 @@ void Foam::conformalVoronoiMesh::addPatches
     faceList& faces,
     labelList& owner,
     PtrList<dictionary>& patchDicts,
-    PackedBoolList& boundaryFacesToRemove,
+    bitSet& boundaryFacesToRemove,
     const List<DynamicList<face>>& patchFaces,
     const List<DynamicList<label>>& patchOwners,
     const List<DynamicList<bool>>& indirectPatchFace
@@ -2531,7 +2531,7 @@ void Foam::conformalVoronoiMesh::removeUnusedPoints
 {
     Info<< nl << "Removing unused points" << endl;
 
-    PackedBoolList ptUsed(pts.size(), false);
+    bitSet ptUsed(pts.size(), false);
 
     // Scan all faces to find all of the points that are used
 
@@ -2585,7 +2585,7 @@ Foam::labelList Foam::conformalVoronoiMesh::removeUnusedCells
 {
     Info<< nl << "Removing unused cells" << endl;
 
-    PackedBoolList cellUsed(vertexCount(), false);
+    bitSet cellUsed(vertexCount(), false);
 
     // Scan all faces to find all of the cells that are used
 

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C

@@ -2271,7 +2271,7 @@ void Foam::conformalVoronoiMesh::reinsertSurfaceConformation()
 
     ptPairs_.reIndex(oldToNewIndices);
 
-    PackedBoolList selectedElems(surfaceConformationVertices_.size(), true);
+    bitSet selectedElems(surfaceConformationVertices_.size(), true);
 
     forAll(surfaceConformationVertices_, vI)
     {
@@ -2295,7 +2295,7 @@ void Foam::conformalVoronoiMesh::reinsertSurfaceConformation()
         }
     }
 
-    inplaceSubset<PackedBoolList, List<Vb>>
+    inplaceSubset<bitSet, List<Vb>>
     (
         selectedElems,
         surfaceConformationVertices_

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C

@@ -115,7 +115,7 @@ void Foam::conformalVoronoiMesh::writeMesh(const fileName& instance)
         wordList patchNames;
         PtrList<dictionary> patchDicts;
         pointField cellCentres;
-        PackedBoolList boundaryFacesToRemove;
+        bitSet boundaryFacesToRemove;
 
         calcDualMesh
         (
@@ -377,7 +377,7 @@ void Foam::conformalVoronoiMesh::writeMesh(const fileName& instance)
 //
 //        Info<< nl << "Writing tetDualMesh to " << instance << endl;
 //
-//        PackedBoolList boundaryFacesToRemove;
+//        bitSet boundaryFacesToRemove;
 //        writeMesh
 //        (
 //            "tetDualMesh",
@@ -773,7 +773,7 @@ void Foam::conformalVoronoiMesh::writeMesh
     const wordList& patchNames,
     const PtrList<dictionary>& patchDicts,
     const pointField& cellCentres,
-    PackedBoolList& boundaryFacesToRemove
+    bitSet& boundaryFacesToRemove
 ) const
 {
     if (foamyHexMeshControls().objOutput())
@@ -949,7 +949,7 @@ void Foam::conformalVoronoiMesh::writeMesh
         orEqOp<unsigned int>()
     );
 
-    labelList addr(boundaryFacesToRemove.used());
+    labelList addr(boundaryFacesToRemove.toc());
 
     faceSet indirectPatchFaces
     (

applications/utilities/mesh/generation/foamyMesh/foamyQuadMesh/CV2D.C

@@ -496,7 +496,7 @@ void Foam::CV2D::newPoints()
     scalar u = 1.0;
     scalar l = 0.7;
 
-    PackedBoolList pointToBeRetained(startOfSurfacePointPairs_, true);
+    bitSet pointToBeRetained(startOfSurfacePointPairs_, true);
 
     std::list<Point> pointsToInsert;
 

applications/utilities/mesh/generation/foamyMesh/foamyQuadMesh/CV2D.H

@@ -122,7 +122,7 @@ SourceFiles
 #include "point2DFieldFwd.H"
 #include "dictionary.H"
 #include "Switch.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "EdgeMap.H"
 #include "cv2DControls.H"
 #include "tolerances.H"

applications/utilities/mesh/manipulation/checkMesh/checkTools.C

@@ -306,7 +306,7 @@ void Foam::mergeAndWrite
 
 
     // Determine faces on outside of cellSet
-    PackedBoolList isInSet(mesh.nCells());
+    bitSet isInSet(mesh.nCells());
     forAllConstIter(cellSet, set, iter)
     {
         isInSet.set(iter.key());

applications/utilities/mesh/manipulation/checkMesh/checkTopology.C

@@ -660,7 +660,7 @@ Foam::label Foam::checkTopology
 
             const cellList& cells = mesh.cells();
             const faceList& faces = mesh.faces();
-            PackedBoolList isZonePoint(mesh.nPoints());
+            bitSet isZonePoint(mesh.nPoints());
 
             for (const cellZone& cZone : cellZones)
             {

applications/utilities/mesh/manipulation/createBaffles/createBaffles.C

@@ -192,7 +192,7 @@ void modifyOrAddFace
     const label zoneID,
     const bool zoneFlip,
 
-    PackedBoolList& modifiedFace
+    bitSet& modifiedFace
 )
 {
     if (modifiedFace.set(facei))
@@ -247,7 +247,7 @@ void createFaces
     const labelList& newMasterPatches,
     const labelList& newSlavePatches,
     polyTopoChange& meshMod,
-    PackedBoolList& modifiedFace,
+    bitSet& modifiedFace,
     label& nModified
 )
 {
@@ -538,15 +538,13 @@ int main(int argc, char *argv[])
         if (mesh.faceZones().findZoneID(name) == -1)
         {
             mesh.faceZones().clearAddressing();
-            label sz = mesh.faceZones().size();
+            const label zoneID = mesh.faceZones().size();
 
-            labelList addr(0);
+            mesh.faceZones().setSize(zoneID+1);
-            boolList flip(0);
-            mesh.faceZones().setSize(sz+1);
             mesh.faceZones().set
             (
-                sz,
+                zoneID,
-                new faceZone(name, addr, flip, sz, mesh.faceZones())
+                new faceZone(name, labelList(), false, zoneID, mesh.faceZones())
             );
         }
     }
@@ -604,7 +602,14 @@ int main(int argc, char *argv[])
         mesh.faceZones().set
         (
             zoneID,
-            new faceZone(name, addr, flip, zoneID, mesh.faceZones())
+            new faceZone
+            (
+                name,
+                std::move(addr),
+                std::move(flip),
+                zoneID,
+                mesh.faceZones()
+            )
         );
     }
 
@@ -751,7 +756,7 @@ int main(int argc, char *argv[])
     //   side come first and faces from the other side next.
 
     // Whether first use of face (modify) or consecutive (add)
-    PackedBoolList modifiedFace(mesh.nFaces());
+    bitSet modifiedFace(mesh.nFaces());
     label nModified = 0;
 
     forAll(selectors, selectorI)

applications/utilities/mesh/manipulation/mergeOrSplitBaffles/mergeOrSplitBaffles.C

@@ -483,7 +483,7 @@ int main(int argc, char *argv[])
             }
             candidates.setCapacity(sz);
 
-            PackedBoolList isCandidate(mesh.nPoints());
+            bitSet isCandidate(mesh.nPoints());
             forAll(splitPatchIDs, i)
             {
                 const labelList& mp = patches[splitPatchIDs[i]].meshPoints();

applications/utilities/mesh/manipulation/orientFaceZone/orientFaceZone.C

@@ -87,7 +87,7 @@ int main(int argc, char *argv[])
 
 
 
-    const PackedBoolList isMasterFace(syncTools::getMasterFaces(mesh));
+    const bitSet isMasterFace(syncTools::getMasterFaces(mesh));
 
 
     // Data on all edges and faces

applications/utilities/mesh/manipulation/polyDualMesh/meshDualiser.C

@@ -146,7 +146,7 @@ Foam::label Foam::meshDualiser::findDualCell
 
 void Foam::meshDualiser::generateDualBoundaryEdges
 (
-    const PackedBoolList& isBoundaryEdge,
+    const bitSet& isBoundaryEdge,
     const label pointi,
     polyTopoChange& meshMod
 )
@@ -374,7 +374,7 @@ Foam::label Foam::meshDualiser::addBoundaryFace
 void Foam::meshDualiser::createFacesAroundEdge
 (
     const bool splitFace,
-    const PackedBoolList& isBoundaryEdge,
+    const bitSet& isBoundaryEdge,
     const label edgeI,
     const label startFacei,
     polyTopoChange& meshMod,
@@ -886,7 +886,7 @@ void Foam::meshDualiser::setRefinement
     // Mark boundary edges and points.
     // (Note: in 1.4.2 we can use the built-in mesh point ordering
     //  facility instead)
-    PackedBoolList isBoundaryEdge(mesh_.nEdges());
+    bitSet isBoundaryEdge(mesh_.nEdges());
     for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
     {
         const labelList& fEdges = mesh_.faceEdges()[facei];

applications/utilities/mesh/manipulation/polyDualMesh/meshDualiser.H

@@ -48,7 +48,7 @@ SourceFiles
 #define meshDualiser_H
 
 #include "DynamicList.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "boolList.H"
 #include "typeInfo.H"
 
@@ -100,7 +100,7 @@ class meshDualiser
         //  emanating from (boundary & feature) point
         void generateDualBoundaryEdges
         (
-            const PackedBoolList& isBoundaryEdge,
+            const bitSet& isBoundaryEdge,
             const label pointi,
             polyTopoChange& meshMod
         );
@@ -143,7 +143,7 @@ class meshDualiser
         void createFacesAroundEdge
         (
             const bool splitFace,
-            const PackedBoolList& isBoundaryEdge,
+            const bitSet& isBoundaryEdge,
             const label edgeI,
             const label startFacei,
             polyTopoChange& meshMod,

applications/utilities/mesh/manipulation/polyDualMesh/polyDualMeshApp.C

@@ -67,7 +67,7 @@ Note
 #include "unitConversion.H"
 #include "polyTopoChange.H"
 #include "mapPolyMesh.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "meshTools.H"
 #include "OFstream.H"
 #include "meshDualiser.H"
@@ -87,7 +87,7 @@ using namespace Foam;
 void simpleMarkFeatures
 (
     const polyMesh& mesh,
-    const PackedBoolList& isBoundaryEdge,
+    const bitSet& isBoundaryEdge,
     const scalar featureAngle,
     const bool concaveMultiCells,
     const bool doNotPreserveFaceZones,
@@ -390,7 +390,7 @@ int main(int argc, char *argv[])
     // Mark boundary edges and points.
     // (Note: in 1.4.2 we can use the built-in mesh point ordering
     //  facility instead)
-    PackedBoolList isBoundaryEdge(mesh.nEdges());
+    bitSet isBoundaryEdge(mesh.nEdges());
     for (label facei = mesh.nInternalFaces(); facei < mesh.nFaces(); facei++)
     {
         const labelList& fEdges = mesh.faceEdges()[facei];

applications/utilities/mesh/manipulation/refineMesh/refineMesh.C

@@ -79,7 +79,7 @@ void printEdgeStats(const polyMesh& mesh)
     scalar minOther = GREAT;
     scalar maxOther = -GREAT;
 
-    PackedBoolList isMasterEdge(syncTools::getMasterEdges(mesh));
+    bitSet isMasterEdge(syncTools::getMasterEdges(mesh));
 
     const edgeList& edges = mesh.edges();
 

applications/utilities/mesh/manipulation/subsetMesh/subsetMesh.C

@@ -303,7 +303,7 @@ void subsetTopoSets
         Info<< "Subsetting " << set.type() << " " << set.name() << endl;
 
         // Map the data
-        PackedBoolList isSet(set.maxSize(mesh));
+        bitSet isSet(set.maxSize(mesh));
         forAllConstIters(set, iter)
         {
             isSet.set(iter.key());

applications/utilities/parallelProcessing/decomposePar/domainDecompositionMesh.C

@@ -32,7 +32,7 @@ Description
 
 #include "domainDecomposition.H"
 #include "IOstreams.H"
-#include "boolList.H"
+#include "bitSet.H"
 #include "cyclicPolyPatch.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -434,7 +434,6 @@ void Foam::domainDecomposition::decomposeMesh()
 //    }
 
 
-
     Info<< "\nDistributing points to processors" << endl;
     // For every processor, loop through the list of faces for the processor.
     // For every face, loop through the list of points and mark the point as
@@ -443,42 +442,19 @@ void Foam::domainDecomposition::decomposeMesh()
 
     forAll(procPointAddressing_, proci)
     {
-        boolList pointLabels(nPoints(), false);
+        bitSet pointsInUse(nPoints(), false);
 
-        // Get reference to list of used faces
+        // For each of the faces used
-        const labelList& procFaceLabels = procFaceAddressing_[proci];
+        for (const label facei : procFaceAddressing_[proci])
-
-        forAll(procFaceLabels, facei)
         {
-            // Because of the turning index, some labels may be negative
+            // Because of the turning index, some face labels may be -ve
-            const labelList& facePoints = fcs[mag(procFaceLabels[facei]) - 1];
+            const labelList& facePoints = fcs[mag(facei) - 1];
 
-            forAll(facePoints, pointi)
+            // Mark the face points as being used
-            {
+            pointsInUse.setMany(facePoints);
-                // Mark the point as used
-                pointLabels[facePoints[pointi]] = true;
-            }
         }
 
-        // Collect the used points
+        procPointAddressing_[proci] = pointsInUse.sortedToc();
-        labelList& procPointLabels = procPointAddressing_[proci];
-
-        procPointLabels.setSize(pointLabels.size());
-
-        label nUsedPoints = 0;
-
-        forAll(pointLabels, pointi)
-        {
-            if (pointLabels[pointi])
-            {
-                procPointLabels[nUsedPoints] = pointi;
-
-                nUsedPoints++;
-            }
-        }
-
-        // Reset the size of used points
-        procPointLabels.setSize(nUsedPoints);
     }
 }
 

applications/utilities/surface/surfaceHookUp/surfaceHookUp.C

@@ -41,7 +41,7 @@ Usage
 #include "triSurfaceMesh.H"
 #include "indexedOctree.H"
 #include "treeBoundBox.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "unitConversion.H"
 #include "searchableSurfaces.H"
 #include "IOdictionary.H"
@@ -329,7 +329,7 @@ int main(int argc, char *argv[])
 
     List<DynamicList<labelledTri>> newFaces(surfs.size());
     List<DynamicList<point>> newPoints(surfs.size());
-    List<PackedBoolList> visitedFace(surfs.size());
+    List<bitSet> visitedFace(surfs.size());
 
     PtrList<triSurfaceMesh> newSurfaces(surfs.size());
     forAll(surfs, surfI)
@@ -370,7 +370,7 @@ int main(int argc, char *argv[])
 
             newFaces[surfI] = newSurf.localFaces();
             newPoints[surfI] = newSurf.localPoints();
-            visitedFace[surfI] = PackedBoolList(newSurf.size(), false);
+            visitedFace[surfI] = bitSet(newSurf.size(), false);
         }
 
         forAll(newSurfaces, surfI)

applications/utilities/surface/surfaceInflate/surfaceInflate.C

@@ -54,7 +54,7 @@ Usage
 #include "triSurfaceFields.H"
 #include "triSurfaceMesh.H"
 #include "triSurfaceGeoMesh.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "OBJstream.H"
 #include "surfaceFeatures.H"
 
@@ -131,7 +131,7 @@ tmp<vectorField> calcVertexNormals(const triSurface& surf)
 tmp<vectorField> calcPointNormals
 (
     const triSurface& s,
-    const PackedBoolList& isFeaturePoint,
+    const bitSet& isFeaturePoint,
     const List<surfaceFeatures::edgeStatus>& edgeStat
 )
 {
@@ -215,7 +215,7 @@ tmp<vectorField> calcPointNormals
 void detectSelfIntersections
 (
     const triSurfaceMesh& s,
-    PackedBoolList& isEdgeIntersecting
+    bitSet& isEdgeIntersecting
 )
 {
     const edgeList& edges = s.edges();
@@ -258,9 +258,9 @@ label detectIntersectionPoints
     const vectorField& displacement,
 
     const bool checkSelfIntersect,
-    const PackedBoolList& initialIsEdgeIntersecting,
+    const bitSet& initialIsEdgeIntersecting,
 
-    PackedBoolList& isPointOnHitEdge,
+    bitSet& isPointOnHitEdge,
     scalarField& scale
 )
 {
@@ -307,7 +307,7 @@ label detectIntersectionPoints
     // 2. (new) surface self intersections
     if (checkSelfIntersect)
     {
-        PackedBoolList isEdgeIntersecting;
+        bitSet isEdgeIntersecting;
         detectSelfIntersections(s, isEdgeIntersecting);
 
         const edgeList& edges = s.edges();
@@ -400,7 +400,7 @@ tmp<scalarField> avg
 void minSmooth
 (
     const triSurface& s,
-    const PackedBoolList& isAffectedPoint,
+    const bitSet& isAffectedPoint,
     const scalarField& fld,
     scalarField& newFld
 )
@@ -442,19 +442,19 @@ void lloydsSmoothing
 (
     const label nSmooth,
     triSurface& s,
-    const PackedBoolList& isFeaturePoint,
+    const bitSet& isFeaturePoint,
     const List<surfaceFeatures::edgeStatus>& edgeStat,
-    const PackedBoolList& isAffectedPoint
+    const bitSet& isAffectedPoint
 )
 {
     const labelList& meshPoints = s.meshPoints();
     const edgeList& edges = s.edges();
 
 
-    PackedBoolList isSmoothPoint(isAffectedPoint);
+    bitSet isSmoothPoint(isAffectedPoint);
     // Extend isSmoothPoint
     {
-        PackedBoolList newIsSmoothPoint(isSmoothPoint);
+        bitSet newIsSmoothPoint(isSmoothPoint);
         forAll(edges, edgeI)
         {
             const edge& e = edges[edgeI];
@@ -539,7 +539,7 @@ void lloydsSmoothing
 
         // Extend isSmoothPoint
         {
-            PackedBoolList newIsSmoothPoint(isSmoothPoint);
+            bitSet newIsSmoothPoint(isSmoothPoint);
             forAll(edges, edgeI)
             {
                 const edge& e = edges[edgeI];
@@ -662,7 +662,7 @@ int main(int argc, char *argv[])
         << " out of " << s.nEdges() << nl
         << endl;
 
-    PackedBoolList isFeaturePoint(s.nPoints(), features.featurePoints());
+    bitSet isFeaturePoint(s.nPoints(), features.featurePoints());
 
     const List<surfaceFeatures::edgeStatus> edgeStat(features.toStatus());
 
@@ -723,11 +723,11 @@ int main(int argc, char *argv[])
 
 
     // Any point on any intersected edge in any of the iterations
-    PackedBoolList isScaledPoint(s.nPoints());
+    bitSet isScaledPoint(s.nPoints());
 
 
     // Detect any self intersections on initial mesh
-    PackedBoolList initialIsEdgeIntersecting;
+    bitSet initialIsEdgeIntersecting;
     if (checkSelfIntersect)
     {
         detectSelfIntersections(s, initialIsEdgeIntersecting);
@@ -775,7 +775,7 @@ int main(int argc, char *argv[])
 
 
         // Detect any intersections and scale back
-        PackedBoolList isAffectedPoint;
+        bitSet isAffectedPoint;
         label nIntersections = detectIntersectionPoints
         (
             1e-9,       // intersection tolerance
@@ -818,7 +818,7 @@ int main(int argc, char *argv[])
             minSmooth
             (
                 s,
-                PackedBoolList(s.nPoints(), true),
+                bitSet(s.nPoints(), true),
                 oldScale,
                 scale
             );

applications/utilities/surface/surfaceLambdaMuSmooth/surfaceLambdaMuSmooth.C

@@ -54,7 +54,7 @@ using namespace Foam;
 tmp<pointField> avg
 (
     const meshedSurface& s,
-    const PackedBoolList& fixedPoints
+    const bitSet& fixedPoints
 )
 {
     const labelListList& pointEdges = s.pointEdges();
@@ -95,7 +95,7 @@ void getFixedPoints
 (
     const edgeMesh& feMesh,
     const pointField& points,
-    PackedBoolList& fixedPoints
+    bitSet& fixedPoints
 )
 {
     scalarList matchDistance(feMesh.points().size(), 1e-1);
@@ -177,7 +177,7 @@ int main(int argc, char *argv[])
         << "Vertices    : " << surf1.nPoints() << nl
         << "Bounding Box: " << boundBox(surf1.localPoints()) << endl;
 
-    PackedBoolList fixedPoints(surf1.localPoints().size(), false);
+    bitSet fixedPoints(surf1.localPoints().size(), false);
 
     if (args.found("featureFile"))
     {

etc/controlDict

@@ -390,6 +390,7 @@ DebugSwitches
     basicMixture        0;
     basicReactingCloud  0;
     basicReactingParcel 0;
+    bitSet              0;
     fluidThermo         0;
     fluidThermoCloud    0;
     fluidThermoParcel   0;

src/OpenFOAM/Make/files

@@ -145,11 +145,12 @@ primitives/polynomialEqns/quadraticEqn/quadraticEqn.C
 primitives/Barycentric/barycentric/barycentric.C
 primitives/Barycentric2D/barycentric2D/barycentric2D.C
 
+containers/Bits/bitSet/bitSet.C
+containers/Bits/bitSet/bitSetIO.C
+containers/Bits/PackedList/PackedListCore.C
 containers/HashTables/HashOps/HashOps.C
 containers/HashTables/HashTable/HashTableCore.C
 containers/Lists/SortableList/ParSortableListName.C
-containers/Lists/PackedList/PackedListCore.C
-containers/Lists/PackedList/PackedBoolList.C
 containers/Lists/ListOps/ListOps.C
 containers/LinkedLists/linkTypes/SLListBase/SLListBase.C
 containers/LinkedLists/linkTypes/DLListBase/DLListBase.C

src/OpenFOAM/containers/Bits/BitOps/BitOps.H

@@ -0,0 +1,192 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Namespace
+    Foam::BitOps
+
+Description
+    Various bit-wise operations, etc.
+
+    The population count uses the Hamming weight
+    (http://en.wikipedia.org/wiki/Hamming_weight).
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef BitOps_H
+#define BitOps_H
+
+#include "label.H"
+#include "Ostream.H"
+#include <limits>
+#include <utility>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Namespace BitOps Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace BitOps
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Count arbitrary number of bits (of an integral type)
+template<class UIntType>
+inline unsigned int bit_count(UIntType x)
+{
+    unsigned int n = 0u;
+
+    for (; x; ++n) { x &= (x-1); }
+
+    return n;
+}
+
+
+//- Count bits in a 32-bit value (Hamming weight method)
+template<>
+inline unsigned int bit_count(uint32_t x)
+{
+    x -= (x >> 1) & 0x55555555;
+    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+
+    return ((((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24);
+}
+
+
+//- Count bits in a 64-bit value (Hamming weight method)
+template<>
+inline unsigned int bit_count(uint64_t x)
+{
+    x -= (x >> 1) & 0x5555555555555555;
+    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
+
+    return unsigned
+        ((((x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F) * 0x0101010101010101) >> 56);
+}
+
+
+//- Repeat a value of the given BitWidth into the destination output type.
+template<class UIntType, unsigned BitWidth>
+inline UIntType repeat_value(unsigned val)
+{
+    static_assert
+    (
+        BitWidth && std::numeric_limits<UIntType>::digits >= BitWidth,
+        "BitWidth too large for target output"
+    );
+
+    // How many fit into the target
+    const unsigned nrepeat = (std::numeric_limits<UIntType>::digits / BitWidth);
+
+    // Max value for a single element
+    const unsigned mask = ((1u << BitWidth) - 1);
+
+    // The first occurance
+    UIntType fillval = ((val >= mask) ? mask : val);
+
+    // Repeated
+    for (unsigned i = 1; i < nrepeat; ++i)
+    {
+        fillval |= (fillval << BitWidth);
+    }
+
+    return fillval;
+}
+
+
+//- Print 0/1 bits in the (unsigned) integral type
+template<class UIntType>
+inline Ostream& print(Ostream& os, UIntType value, char off='0', char on='1')
+{
+    if (os.format() == IOstream::BINARY)
+    {
+        // Perhaps not the most sensible, but the only thing we currently have.
+        os << label(value);
+    }
+    else
+    {
+        // Starting from most significant bit - makes for easy reading.
+        for
+        (
+            unsigned test = (1u << (std::numeric_limits<UIntType>::digits-1));
+            test;
+            test >>= 1u
+        )
+        {
+            os << ((value & test) ? on : off);
+        }
+    }
+
+    return os;
+}
+
+
+//- An (unsigned) integral type adapter, for output of bit values
+template<class UIntType>
+struct bitInfo
+{
+    typedef UIntType value_type;
+
+    value_type value;
+
+    //- Null constructible as zero
+    bitInfo() : value(0) {}
+
+    //- Value construct
+    explicit bitInfo(UIntType val) : value(val) {}
+
+    //- Conversion to base type
+    operator UIntType () const { return value; }
+
+    //- Conversion to base type
+    operator UIntType& () { return value; }
+};
+
+
+} // End namespace BitOps
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Print 0/1 bits of an (unsigned) integral type via an adapter
+template<class UIntType>
+inline Ostream& operator<<(Ostream& os, const BitOps::bitInfo<UIntType>& info)
+{
+    BitOps::print(os, info.value);
+    return os;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

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

@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "PackedList.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<unsigned Width>
+bool Foam::PackedList<Width>::uniform() const
+{
+    if (size() < 2)
+    {
+        return false;   // Trivial case
+    }
+
+    // The value of the first element for testing
+    const unsigned int val = get(0);
+
+    const label nblocks = num_blocks(size());
+
+    bool identical = true;
+
+    if (!val)
+    {
+        // Zero value: can just check block content directly
+
+        for (label blocki = 0; identical && blocki < nblocks; ++blocki)
+        {
+            identical = !blocks_[blocki];
+        }
+
+        return identical;
+    }
+    else if (nblocks > 1)
+    {
+        // Check all blocks that are completely occupied: (nblocks-1)
+        const unsigned int blockval =
+            BitOps::repeat_value<block_type,Width>(val);
+
+        for (label blocki = 0; identical && blocki < (nblocks-1); ++blocki)
+        {
+            identical = (blocks_[blocki] == blockval);
+        }
+    }
+
+    // Partial block: check manually
+    for
+    (
+        label elemi = elem_per_block*(nblocks-1);
+        identical && elemi < size();
+        ++elemi
+    )
+    {
+        identical = (val == get(elemi));
+    }
+
+    return identical;
+}
+
+
+template<unsigned Width>
+Foam::labelList Foam::PackedList<Width>::values() const
+{
+    if (size() < 2 || uniform())
+    {
+        const label val = (size() ? get(0) : 0);
+
+        return labelList(size(), val);
+    }
+
+    labelList output(size());
+    label outi = 0;
+
+    // Process n-1 complete blocks
+    const label nblocks = num_blocks(size());
+
+    for (label blocki=0; blocki < nblocks-1; ++blocki)
+    {
+        unsigned int blockval = blocks_[blocki];
+
+        for (unsigned nget = elem_per_block; nget; --nget, ++outi)
+        {
+            output[outi] = label(blockval & max_value);
+            blockval >>= Width;
+        }
+    }
+
+    // Any partial blocks
+    for (/*nil*/; outi < size(); ++outi)
+    {
+        output[outi] = get(outi);
+    }
+
+    return output;
+}
+
+
+// ************************************************************************* //

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

@@ -25,11 +25,11 @@ Class
     Foam::PackedList
 
 Description
-    A dynamically list of packed unsigned integers, with the number of bits
+    A dynamic list of packed unsigned integers, with the number of bits
-    per item specified by the \<nBits\> template parameter.
+    per item specified by the \<Width\> template parameter.
 
     Resizing is similar to DynamicList so that clear() and resize() affect
-    the addessed size, but not the allocated size. The reserve() and
+    the addressed size, but not the allocated size. The reserve() and
     setCapacity() methods can be used to influence the allocation.
 
 Note
@@ -37,13 +37,20 @@ Note
     with out-of-range elements returned as zero.
 
     In a non-const context, the '[]' operator returns a reference to an
-    existing value. Some caution with out-of-range elements to ensure
+    existing value. When accessing out-of-range elements, some caution
-    that the const version of the [] operator is being called.
+    is required to ensure that the const version of the [] operator is actually
-    The get() method is functionally identical to the '[]' operator, but
+    being called.
+    The get() method is functionally identical the the '[]' operator, but
     is always const access.
 
     The set() and unset() methods return a bool if the value changed.
-    This can be useful for branching on changed values.
+
+    With const access, the get() method and 'operator[]' are identical.
+    With non-const access, the 'operator[]' may be marginally slower get().
+
+    The set() method may be marginally faster than using the 'operator[]'
+    supports auto-vivification and also returns a bool if the value changed,
+    which can be useful for branching on changed values.
 
     \code
         list.set(5, 4);
@@ -56,27 +63,38 @@ Note
     For example,
     \code
         list.resize(4);
-        Info<< list.get(10) << "\n";  // print zero, but doesn't adjust list
+        Info<< list.get(10) << "\n";    // print zero, but doesn't adjust list
+        list.set(8);                    // auto-vivify
     \endcode
 
     Also note that all unused internal storage elements are guaranteed to
     always be bit-wise zero. This property must not be violated by any
     inheriting classes.
 
+Note
+    Iterators for this class have been intentionally removed, for performance
+    reasons.
+
 See also
+    Foam::BitOps
     Foam::DynamicList
 
 SourceFiles
     PackedListI.H
     PackedList.C
+    PackedListIO.C
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef PackedList_H
 #define PackedList_H
 
+#include "BitOps.H"
 #include "labelList.H"
 #include "UIndirectList.H"
+#include "InfoProxy.H"
+#include "PackedListCore.H"
+
 #include <type_traits>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -85,51 +103,102 @@ namespace Foam
 {
 
 // Forward declarations
-template<unsigned nBits> class PackedList;
+template<unsigned Width> class PackedList;
 class Istream;
 class Ostream;
 
-template<unsigned nBits>
+template<unsigned Width>
-Istream& operator>>(Istream& is, PackedList<nBits>& lst);
+Istream& operator>>(Istream& is, PackedList<Width>& list);
-template<unsigned nBits>
-Ostream& operator<<(Ostream& os, const PackedList<nBits>& lst);
 
+template<unsigned Width>
+Ostream& operator<<(Ostream& os, const PackedList<Width>& list);
 
-/*---------------------------------------------------------------------------*\
+template<unsigned Width>
-                       Class PackedListCore Declaration
+Ostream& operator<<(Ostream& os, const InfoProxy<PackedList<Width>>& info);
-\*---------------------------------------------------------------------------*/
-
-//- Template-invariant bits for PackedList
-struct PackedListCore
-{
-    //- Construct null
-    PackedListCore()
-    {}
-
-    //- Define template name and debug
-    ClassName("PackedList");
-};
 
 
 /*---------------------------------------------------------------------------*\
                          Class PackedList Declaration
 \*---------------------------------------------------------------------------*/
 
-template<unsigned nBits=1>
+template<unsigned Width>
 class PackedList
 :
-    public PackedListCore,
+    public Detail::PackedListCore
-    private List<unsigned int>
 {
+public:
+
+    // Types and dimension information
+
+        //- The storage block type for bit elements
+        typedef unsigned int block_type;
+
+        //- The number of bits in a single block
+        static constexpr unsigned bits_per_block
+            = (std::numeric_limits<block_type>::digits);
+
+        //- The width of an individual element (in bits).
+        static constexpr unsigned element_width = (Width);
+
+        //- The number of elements stored per data block.
+        static constexpr unsigned elem_per_block = (bits_per_block / Width);
+
+        //- The max value for an element which is also the bit-mask of the
+        //- individual element.
+        //  Eg, for Width=2: ((1 << 2) - 1) == 0b0011
+        static constexpr block_type max_value = ((1u << Width) - 1);
+
+        //- Calculate the number of blocks required to _address_ the
+        //- requested number of elements.
+        //
+        // We calculate this:
+        // \code
+        //     (numElem / elem_per_block)
+        //   + (numElem % elem_per_block) ? 1 : 0
+        // \code
+        // But avoiding the modulus operation
+        static constexpr label num_blocks(label numElem)
+        {
+            return ((numElem - 1 + elem_per_block) / elem_per_block);
+        }
+
+        //- Masking for all bits below the element offset.
+        //  Ill-defined when elementOffset is out of range.
+        static constexpr block_type mask_lower(unsigned elementOffset)
+        {
+            return (~0u >> (bits_per_block - Width * elementOffset));
+        }
+
+
 protected:
 
-    typedef unsigned int      StorageType;
+    // Protected Data
-    typedef List<StorageType> StorageList;
+
+        //- The internal container for storing the blocks
+        typedef List<block_type> block_container;
+
+        //- The blocks of raw data
+        block_container blocks_;
+
+        //- Number of entries used
+        label size_;
+
+        //- Enforce non-zero Width to fit within the block storage and require
+        //- at least 2 items per storage block for general efficiency.
+        //
+        //  Thus 1/2 of the base storage size is (sizeof(block_type)*8/2),
+        //  or (sizeof(block_type) << 2)
+        static_assert
+        (
+            Width && Width <= (sizeof(block_type) << 2),
+            "Width must be > 0 and minimum of two items per data block"
+        );
+
 
     // Protected Member Functions
 
-        //- Calculate the list length when packed
+        //- A fill value for complete blocks
-        inline static constexpr label packedLength(const label nElem);
+        inline static unsigned int repeated_value(unsigned val);
 
         //- Read a list entry (allows for specialization)
         inline static unsigned int readValue(Istream& is);
@@ -138,33 +207,13 @@ protected:
         //  For bool specialization, read a single index value
         inline void setPair(Istream& is);
 
-
-private:
-
-    //- nBits must be positive (non-zero) and fit within the storage.
-    //  For efficiency, however, require packing at least 2 items otherwise
-    //  it is more efficient to use a normal list.
-    //  Thus max nBits is 1/2 of the base storage size.
-    //  For simplicity, assume 8-bit bytes in the assert.
-    static_assert
-    (
-        nBits && nBits <= (sizeof(StorageType) << 2),
-        "nBits must be positive (non-zero) and fit within the storage"
-    );
-
-    // Private data
-
-        //- Number of nBits entries
-        label size_;
-
-
-protected:
-
-    // Protected Member Functions
-
         //- Write as a dictionary entry
         void writeEntry(Ostream& os) const;
 
+        //- Clear any partial rubbish in the last addressable block
+        //  This \a rubbish may have arisen from block-wise operations etc.
+        inline void clear_trailing_bits();
+
 
 public:
 
@@ -174,129 +223,93 @@ public:
         typedef unsigned int const_reference;
 
 
-    // Public data
-
-        //- The max. number of bits that can be templated.
-        //  Might someday be useful for a template assert.
-        inline static constexpr unsigned int max_bits();
-
-        //- The max. value for an entry, which simultaneously the bit-mask
-        //  eg, ((1 << 2) - 1) yields 0b0011
-        inline static constexpr unsigned int max_value();
-
-        //- The number of entries per packed storage element
-        inline static constexpr unsigned int packing();
-
-        //- Masking for all bits below the offset
-        inline static constexpr unsigned int maskLower(unsigned offset);
-
-
     // Constructors
 
         //- Null constructor
-        inline PackedList();
+        inline constexpr PackedList() noexcept;
 
-        //- Construct with given size, initializes list to 0
+        //- Construct for given number of elements, initializes values to 0
-        explicit inline PackedList(const label size);
+        explicit inline PackedList(const label numElem);
 
-        //- Construct with given size and value for all elements
+        //- Construct for given number of elements, and the specified
-        inline PackedList(const label size, const unsigned val);
+        //- value for each element
+        inline PackedList(const label numElem, const unsigned int val);
 
         //- Construct from Istream
         inline PackedList(Istream& is);
 
         //- Copy construct
-        inline PackedList(const PackedList<nBits>& lst);
+        inline PackedList(const PackedList<Width>& rhs);
 
         //- Move construct
-        inline PackedList(PackedList<nBits>&& lst);
+        inline PackedList(PackedList<Width>&& rhs);
 
-        //- Construct from a list of labels
+        //- Construct from a list of values
-        explicit inline PackedList(const labelUList& lst);
+        explicit inline PackedList(const labelUList& values);
 
-        //- Construct from an indirect list of labels
+        //- Construct from a list of values
-        explicit inline PackedList(const labelUIndList& lst);
+        explicit inline PackedList(const labelUIndList& values);
 
         //- Clone
-        inline autoPtr<PackedList<nBits>> clone() const;
+        inline autoPtr<PackedList<Width>> clone() const;
 
 
     // Member Functions
 
-    // Access
+    // Query
-
-        //- The number of elements that can be stored before reallocating
-        inline label capacity() const;
-
-        //- Number of entries.
-        inline label size() const;
-
-        //- Return true if the list is empty (ie, size() is zero).
-        inline bool empty() const;
-
-        //- Get value at index I.
-        //  Never auto-vivify entries.
-        inline unsigned int get(const label i) const;
-
-        //- Set value at index I, default value set is the max_value.
-        //  Does auto-vivify for non-existent, non-zero entries.
-        //  \return true if value changed.
-        inline bool set(const label i, const unsigned int val = ~0u);
-
-        //- Unset the entry at index I.
-        //  Never auto-vivify entries.
-        //  \return true if value changed.
-        inline bool unset(const label i);
-
-        //- Return the underlying packed storage
-        //  Manipulate with utmost caution
-        inline List<unsigned int>& storage();
-
-        //- Return the underlying packed storage
-        inline const List<unsigned int>& storage() const;
-
-        //- The list length when packed
-        inline label packedLength() const;
-
-        //- The number of bytes used in the underlying storage
-        inline std::streamsize byteSize() const;
-
-        //- Count number of bits set, O(log(n))
-        //  Uses the Hamming weight (population count) method
-        //  http://en.wikipedia.org/wiki/Hamming_weight
-        unsigned int count() const;
-
-        //- Return the values as a list of labels
-        labelList values() const;
-
-        //- Print bit patterns, optionally output unused elements
-        //
-        // addressable bits:
-        //   on: '1', off: '-'
-        //
-        // non-addressable bits:
-        //   on: '!', off: '.'
-        //
-        Ostream& printBits(Ostream& os, const bool fullOutput=false) const;
-
-        //- Print information and bit patterns (with printBits)
-        Ostream& printInfo(Ostream& os, const bool fullOutput=false) const;
-
-    // Check
 
         //- Check index is within valid range [0,size)
         inline void checkIndex(const label i) const;
 
+        //- Number of entries.
+        inline label size() const noexcept;
+
+        //- Return true if the list is empty (ie, size() is zero).
+        inline bool empty() const noexcept;
+
+        //- The number of elements that can be stored with reallocating
+        inline label capacity() const;
+
+        //- True if there are two or more entries and all entries have
+        //- identical values.
+        bool uniform() const;
+
+
+    // Access
+
+        //- Get value at index i or 0 for out-of-range.
+        //  Never auto-vivify entries.
+        inline unsigned int get(const label i) const;
+
+        //- Set value at index i, default value set is the max_value.
+        //  Does auto-vivify for non-existent, non-zero entries.
+        //  \return true if value changed.
+        inline bool set(const label i, unsigned int val = ~0u);
+
+        //- Unset the entry at index i.
+        //  Never auto-vivify entries.
+        //  \return true if the value changed.
+        inline bool unset(const label i);
+
+        //- Return the values as a list of labels
+        labelList values() const;
+
 
     // Edit
 
-        //- Trim any trailing zero elements
+        //- Assign all entries to the given value. Takes linear time.
-        bool trim();
+        inline void assign(const unsigned int val);
 
-        //- Invert the bits in the addressable region
+        //- Copy assignment.
-        void flip();
+        inline void assign(const PackedList<Width>& rhs);
 
-        //- Clear all bits
+        //- Trim any trailing zero elements, optionally specifying a
+        //- a minimum position, below which trimming will not occur.
+        //
+        //  \return true if trimming changed the size.
+        inline bool trim(label minpos=-1);
+
+        //- Clear all bits but do not adjust the addressable size.
         inline void reset();
 
         //- Alter the size of the underlying storage.
@@ -327,13 +340,36 @@ public:
         //- Shrink the allocated space to what is actually used.
         inline void shrink();
 
+        //- Swap contents with argument
+        inline void swap(PackedList<Width>& rhs);
+
         //- Transfer the contents of the argument list into this list
         //  and annul the argument list.
-        inline void transfer(PackedList<nBits>& lst);
+        inline void transfer(PackedList<Width>& rhs);
+
+
+    // Low-level access
+
+        //- The number of bytes used in the underlying storage
+        //- including any unused padding.
+        inline std::streamsize byteSize() const;
+
+        //- The number of internal storage blocks
+        inline label nBlocks() const;
+
+        //- Return the underlying storage blocks
+        inline const List<unsigned int>& storage() const;
+
+        //- Return the underlying storage blocks
+        //  Manipulate with utmost caution
+        inline List<unsigned int>& storage();
 
 
     // IO
 
+        //- Print bit patterns, optionally with extra debug
+        Ostream& printBits(Ostream& os, bool debugOutput=false) const;
+
         //- Clear list and read from stream
         Istream& read(Istream& is);
 
@@ -349,7 +385,7 @@ public:
     // Member Operators
 
         //- Append a value at the end of the list
-        inline PackedList<nBits>& append(const unsigned int val);
+        inline PackedList<Width>& append(const unsigned int val);
 
         //- Remove and return the last element
         inline unsigned int remove();
@@ -366,32 +402,30 @@ public:
         inline void operator=(const unsigned int val);
 
         //- Copy assignment.
-        void operator=(const PackedList<nBits>& lst);
+        inline void operator=(const PackedList<Width>& lst);
 
         //- Move assignment.
-        void operator=(PackedList<nBits>&& lst);
+        inline void operator=(PackedList<Width>&& lst);
-
-        //- Assignment operator.
-        void operator=(const labelUList& lst);
-
-        //- Assignment operator.
-        void operator=(const labelUIndList& lst);
 
 
-    // Iterators and helpers
+    // Access helpers
 
-        //- A reference for read/write access to an entry
+        //- A reference supporting read/write access to an entry
         class reference
         {
-            friend class PackedList;    // Access for PackedList
+        protected:
+            friend class PackedList;    // Access for parent
             void operator&() = delete;  // Refuse to provide its address
 
-            unsigned int& ref_;   //!< Reference to underlying block value
+            //- Reference to the block
-            unsigned int shift_;  //!< The bit shift for the sub-portion
+            block_type& ref_;
 
-            //- Construct by taking reference of block from within the list
+            //- The bit shift to access the given sub-portion
-            //- at the specified index.
+            unsigned shift_;
-            inline reference(PackedList* lst, const label index);
+
+            //- Construct by taking reference of block from within
+            //- the list and the specified index.
+            inline reference(PackedList* parent, const label index);
 
             //- Get value as unsigned, no range-checking
             inline unsigned int get() const;
@@ -404,27 +438,40 @@ public:
             //- Value assignment
             inline void operator=(const reference& other);
 
-            //- Value assignment
+            //- Value assignment.
             inline void operator=(const unsigned int val);
 
-            //- Conversion operator
+            //- Conversion operator.
             inline operator unsigned int () const;
         };
 
 
     // IOstream Operators
 
-        friend Istream& operator>> <nBits>
+        //- Return info proxy.
-        (
+        InfoProxy<PackedList<Width>> info() const
-            Istream& is,
+        {
-            PackedList<nBits>& lst
+            return *this;
-        );
+        }
 
-        friend Ostream& operator<< <nBits>
+        friend Ostream& operator<< <Width>
         (
             Ostream& os,
-            const PackedList<nBits>& lst
+            const InfoProxy<PackedList<Width>>& info
         );
+
+        friend Istream& operator>> <Width>
+        (
+            Istream& is,
+            PackedList<Width>& list
+        );
+
+        friend Ostream& operator<< <Width>
+        (
+            Ostream& os,
+            const PackedList<Width>& list
+        );
+
 };
 
 
@@ -440,6 +487,7 @@ public:
 
 #ifdef NoRepository
     #include "PackedList.C"
+    #include "PackedListIO.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,14 +23,16 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "PackedList.H"
+#include "PackedListCore.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-defineTypeNameAndDebug(PackedListCore, 0);
+namespace Detail
+{
+    defineTypeName(PackedListCore);
+}
 }
 
-
 // ************************************************************************* //

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

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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::Detail::PackedListCore
+
+Description
+    Implementation of template-invariant details for Foam::PackedList
+
+SourceFiles
+    PackedListCore.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef PackedListCore_H
+#define PackedListCore_H
+
+#include "className.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Detail
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class Detail::PackedListCore Declaration
+\*---------------------------------------------------------------------------*/
+
+//- Template-invariant parts for PackedList
+struct PackedListCore
+{
+    //- Define template name
+    ClassNameNoDebug("PackedList");
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Detail
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

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

@@ -0,0 +1,753 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 "error.H"
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<unsigned Width>
+inline unsigned int Foam::PackedList<Width>::repeated_value(unsigned val)
+{
+    std::cout << "call repeated_value" << nl;
+    return BitOps::repeat_value<block_type,Width>(val);
+}
+
+
+template<unsigned Width>
+inline unsigned int Foam::PackedList<Width>::readValue(Istream& is)
+{
+    const unsigned int val = readLabel(is);
+
+    if (val > max_value)
+    {
+        FatalIOErrorInFunction(is)
+            << "Out-of-range value " << val << " for PackedList<" << Width
+            << ">. Maximum permitted value is " << max_value << "."
+            << exit(FatalIOError);
+    }
+
+    return val;
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::setPair(Istream& is)
+{
+    is.readBegin("Tuple2<label,uint32>");
+
+    const label ind = readLabel(is);
+    const unsigned int val = readLabel(is);
+
+    is.readEnd("Tuple2<label,uint32>");
+
+    if (val > max_value)
+    {
+        FatalIOErrorInFunction(is)
+            << "Out-of-range value " << val << " for PackedList<" << Width
+            << "> at index " << ind
+            << ". Maximum permitted value is " << max_value << "."
+            << exit(FatalIOError);
+    }
+
+    set(ind, val);
+
+    is.check(FUNCTION_NAME);
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::clear_trailing_bits()
+{
+    // Mask off any partial rubbish in final block
+    const unsigned int blk = size() / elem_per_block;
+    const unsigned int off = size() % elem_per_block;
+
+    if (off)
+    {
+        blocks_[blk] &= mask_lower(off);
+    }
+}
+
+
+template<unsigned Width>
+inline bool Foam::PackedList<Width>::trim(label minpos)
+{
+    if (empty())
+    {
+        return false;  // Trivial case
+    }
+
+    const label orig = size();
+    if (orig < minpos)
+    {
+        minpos = orig;   // Don't allow allow accidental growth!
+    }
+
+    for (label blocki = num_blocks(size())-1; blocki >= 0; --blocki)
+    {
+        // Truncate to the block begin
+        size_ = blocki * elem_per_block;
+
+        unsigned int blockval = blocks_[blocki];
+
+        // Some bits were found in the block, increment size again
+        if (blockval)
+        {
+            for (; blockval; ++size_)
+            {
+                blockval >>= Width;
+            }
+            break;
+        }
+        else if (size_ < minpos)
+        {
+            break;
+        }
+    }
+
+    if (size_ < minpos)
+    {
+        size_ = minpos;
+    }
+
+    return (size() != orig);
+}
+
+
+// * * * * * * * * * * * * * * * 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);
+    }
+
+    template<> inline void PackedList<1>::setPair(Istream& is)
+    {
+        set(readLabel(is), true);
+    }
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<unsigned Width>
+inline constexpr Foam::PackedList<Width>::PackedList() noexcept
+:
+    blocks_(),
+    size_(0)
+{}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::PackedList(const label numElem)
+:
+    blocks_(num_blocks(numElem), 0u),
+    size_(numElem)
+{}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::PackedList
+(
+    const label numElem,
+    const unsigned int val
+)
+:
+    blocks_(num_blocks(numElem), 0u),
+    size_(numElem)
+{
+    if (val)
+    {
+        operator=(val);
+    }
+}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::PackedList(Istream& is)
+:
+    blocks_(),
+    size_(0)
+{
+    read(is);
+}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::PackedList(const PackedList<Width>& rhs)
+:
+    blocks_(rhs.blocks_),
+    size_(rhs.size_)
+{}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::PackedList(PackedList<Width>&& rhs)
+:
+    blocks_(std::move(rhs.blocks_)),
+    size_(rhs.size_)
+{
+    rhs.size_ = 0;
+}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::PackedList(const labelUList& values)
+:
+    blocks_(num_blocks(values.size()), 0u),
+    size_(values.size())
+{
+    const label len = values.size();
+
+    // Could add more intelligent filling (blockwise), but likely done
+    // fairly infrequently
+
+    for (label i = 0; i < len; ++i)
+    {
+        const unsigned int val(values[i]);
+        if (val) set(i, val);
+    }
+}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::PackedList(const labelUIndList& values)
+:
+    blocks_(num_blocks(values.size()), 0u),
+    size_(values.size())
+{
+    const label len = values.size();
+
+    // Could add more intelligent filling (blockwise), but likely done
+    // fairly infrequently
+
+    for (label i = 0; i < len; ++i)
+    {
+        const unsigned int val(values[i]);
+        if (val) set(i, val);
+    }
+}
+
+
+template<unsigned Width>
+inline Foam::autoPtr<Foam::PackedList<Width>>
+Foam::PackedList<Width>::clone() const
+{
+    return autoPtr<PackedList<Width>>::New(*this);
+}
+
+
+// * * * * * * * * * * * * * * * * References * * * * * * * * * * * * * * * * //
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::reference::reference
+(
+    PackedList<Width>* parent,
+    const label index
+)
+:
+    ref_(parent->blocks_[index / elem_per_block]),
+    shift_(Width * (index % elem_per_block))
+{}
+
+
+template<unsigned Width>
+inline unsigned int Foam::PackedList<Width>::reference::get() const
+{
+    return ((ref_ >> shift_) & max_value);
+}
+
+
+template<unsigned Width>
+inline bool Foam::PackedList<Width>::reference::set(const unsigned int val)
+{
+    const unsigned int mask = (max_value << shift_);
+    const unsigned int prev = ref_;
+
+    if (val >= max_value)
+    {
+        ref_ |= mask;  // Overflow is max_value, so fill entirely
+    }
+    else
+    {
+        ref_ &= ~mask;
+        ref_ |= mask & (val << shift_);
+    }
+
+    return (prev != ref_);
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::reference::operator=
+(
+    const reference& other
+)
+{
+    this->set(other.get());
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::reference::operator=
+(
+    const unsigned int val
+)
+{
+    this->set(val);
+}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>::reference::operator unsigned int () const
+{
+    return this->get();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::checkIndex(const label i) const
+{
+    if (!size_)
+    {
+        FatalErrorInFunction
+            << "attempt to access element " << i << " from zero sized list"
+            << abort(FatalError);
+    }
+    else if (i < 0 || i >= size_)
+    {
+        FatalErrorInFunction
+            << "index " << i << " out of range [0," << size_ << ")"
+            << abort(FatalError);
+    }
+}
+
+
+template<unsigned Width>
+inline Foam::label Foam::PackedList<Width>::size() const noexcept
+{
+    return size_;
+}
+
+
+template<unsigned Width>
+inline bool Foam::PackedList<Width>::empty() const noexcept
+{
+    return !size_;
+}
+
+
+template<unsigned Width>
+inline Foam::label Foam::PackedList<Width>::capacity() const
+{
+    return elem_per_block * blocks_.size();
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::resize
+(
+    const label newSize,
+    const unsigned int val
+)
+{
+    reserve(newSize);
+
+    const label oldSize = size();
+    size_ = newSize;
+
+    if (oldSize < size())
+    {
+        // Fill new elements or newly exposed elements
+        if (val)
+        {
+            // Fill value for complete blocks
+            const unsigned int blockval = repeated_value(val);
+
+            // Fill complete blocks
+            const label oldLen = num_blocks(oldSize);
+            const label newLen = num_blocks(size());
+            for (label blocki = oldLen; blocki < newLen; ++blocki)
+            {
+                blocks_[blocki] = blockval;
+            }
+
+            // Finish previous partial block, preserve existing value
+            {
+                const unsigned int blk = oldSize / elem_per_block;
+                const unsigned int off = oldSize % elem_per_block;
+                if (off)
+                {
+                    const unsigned int mask = mask_lower(off);
+
+                    blocks_[blk] &= mask;
+                    blocks_[blk] |= ~mask & blockval;
+                }
+            }
+
+            clear_trailing_bits();
+        }
+    }
+    else if (size() < oldSize)
+    {
+        // The list is now shorter than before, so we zero assign the unused
+        // blocks and any trailing junk. This costs slightly here, but make
+        // things much simpler elsewhere.
+
+        // Clear complete blocks
+        const label oldLen = num_blocks(oldSize);
+        const label newLen = num_blocks(size());
+        for (label blocki = newLen; blocki < oldLen; ++blocki)
+        {
+            blocks_[blocki] = 0u;
+        }
+
+        clear_trailing_bits();
+    }
+}
+
+
+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)
+{
+    const label nblocks = num_blocks(numElem);
+
+    blocks_.resize(nblocks, 0u);
+
+    if (numElem < size())
+    {
+        size_ = numElem;
+        clear_trailing_bits();
+    }
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::reserve(const label numElem)
+{
+    const label oldLen = blocks_.size();
+    const label newLen = num_blocks(numElem);
+
+    // Allocate more capacity if necessary
+    if (oldLen < newLen)
+    {
+        blocks_.resize
+        (
+            // SizeMin=16, allocation doubling
+            max(16, max(newLen, 2*oldLen)),
+            0u
+        );
+    }
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::reset()
+{
+    blocks_ = 0u;
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::clear()
+{
+    reset();
+    size_ = 0;
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::clearStorage()
+{
+    blocks_.clear();
+    size_ = 0;
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::shrink()
+{
+    // Any unneeded space allocated?
+    const label nblocks = num_blocks(size());
+    if (nblocks < blocks_.size())
+    {
+        blocks_.resize(nblocks);
+    }
+}
+
+
+template<unsigned Width>
+inline Foam::List<unsigned int>& Foam::PackedList<Width>::storage()
+{
+    return blocks_;
+}
+
+
+template<unsigned Width>
+inline const Foam::List<unsigned int>& Foam::PackedList<Width>::storage() const
+{
+    return blocks_;
+}
+
+
+template<unsigned Width>
+inline Foam::label Foam::PackedList<Width>::nBlocks() const
+{
+    return num_blocks(size());
+}
+
+
+template<unsigned Width>
+inline std::streamsize Foam::PackedList<Width>::byteSize() const
+{
+    return num_blocks(size()) * sizeof(block_type);
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::swap(PackedList<Width>& rhs)
+{
+    blocks_.swap(rhs.blocks_);
+    Foam::Swap(size_, rhs.size_);
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::transfer(PackedList<Width>& rhs)
+{
+    blocks_.transfer(rhs.blocks_);
+
+    size_ = rhs.size_;
+    rhs.size_ = 0;
+}
+
+
+template<unsigned Width>
+inline unsigned int Foam::PackedList<Width>::get(const label i) const
+{
+    if (i < 0 || i >= size())
+    {
+        #ifdef FULLDEBUG
+        if (i < 0)
+        {
+            WarningInFunction
+                << "Ignoring attempt to get a negative index " << i
+                << " range is [0," << size_ << ")"
+                << endl;
+        }
+        #endif
+
+        // Lazy evaluation - return 0 for out-of-range
+        return 0u;
+    }
+
+    return reference(const_cast<PackedList<Width>*>(this), i).get();
+}
+
+
+template<unsigned Width>
+inline bool Foam::PackedList<Width>::set
+(
+    const label i,
+    const unsigned int val
+)
+{
+    if (i < 0)
+    {
+        #ifdef FULLDEBUG
+        WarningInFunction
+            << "Ignoring attempt to set a negative index " << i
+            << " range is [0," << size_ << ")"
+            << endl;
+        }
+        #endif
+
+        // Lazy evaluation - ignore out-of-bounds
+        return false;
+    }
+    else if (i >= size())
+    {
+        if (!val)
+        {
+            // Same as unset out-of-bounds = noop
+            return false;
+        }
+
+        // Lazy evaluation - increase size on assigment
+        resize(i + 1);
+    }
+
+    return reference(this, i).set(val);
+}
+
+
+template<unsigned Width>
+inline bool Foam::PackedList<Width>::unset(const label i)
+{
+    if (i < 0 || i >= size())
+    {
+        // Unset out-of-bounds = noop
+        return false;
+    }
+
+    return reference(this, i).set(0u);
+}
+
+
+template<unsigned Width>
+inline Foam::PackedList<Width>&
+Foam::PackedList<Width>::append(const unsigned int val)
+{
+    const label idx = size();
+    reserve(idx + 1);
+    ++size_;
+
+    reference(this, idx).set(val);
+    return *this;
+}
+
+
+template<unsigned Width>
+inline unsigned int Foam::PackedList<Width>::remove()
+{
+    // Location of last element and simultaneously the new size
+    const label idx = size()-1;
+
+    if (idx < 0)
+    {
+        FatalErrorInFunction
+            << "List is empty" << abort(FatalError);
+    }
+
+    const unsigned int old = reference(this, idx).get();
+    resize(idx);
+
+    return old;
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::assign(const unsigned int val)
+{
+    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);
+
+    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_;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<unsigned Width>
+inline unsigned int Foam::PackedList<Width>::operator[](const label i) const
+{
+    return get(i);
+}
+
+
+template<unsigned Width>
+inline typename Foam::PackedList<Width>::reference
+Foam::PackedList<Width>::operator[](const label i)
+{
+    // Leave enabled during testing period (MAR-2018)
+    // #ifdef FULLDEBUG
+    checkIndex(i);
+    // #endif
+    return reference(this, 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);
+}
+
+
+template<unsigned Width>
+inline void Foam::PackedList<Width>::operator=(PackedList<Width>&& rhs)
+{
+    transfer(rhs);
+}
+
+
+// ************************************************************************* //

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

@@ -0,0 +1,314 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "PackedList.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<unsigned Width>
+void Foam::PackedList<Width>::writeEntry(Ostream& os) const
+{
+    os  << *this;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<unsigned Width>
+Foam::Ostream& Foam::PackedList<Width>::printBits
+(
+    Ostream& os,
+    bool debugOutput
+) const
+{
+    os << token::BEGIN_LIST << nl;
+
+    const label nblocks = debugOutput ? blocks_.size() : num_blocks(size());
+    for (label blocki = 0; blocki < nblocks; ++blocki)
+    {
+        BitOps::print(os, blocks_[blocki], '.') << nl;
+    }
+
+    os << token::END_LIST << nl;
+
+    return os;
+}
+
+
+template<unsigned Width>
+Foam::Istream& Foam::PackedList<Width>::read(Istream& is)
+{
+    PackedList<Width>& list = *this;
+
+    list.clear();
+    is.fatalCheck(FUNCTION_NAME);
+
+    token firstTok(is);
+    is.fatalCheck
+    (
+        "PackedList::read(Istream&) : "
+        "reading first token"
+    );
+
+    if (firstTok.isLabel())
+    {
+        const label len = firstTok.labelToken();
+
+        // Set list length to that read
+        list.resize(len);
+
+        // Read list contents depending on data format
+        if (is.format() == IOstream::ASCII)
+        {
+            // Read beginning of contents
+            const char delimiter = is.readBeginList("PackedList");
+
+            if (len)
+            {
+                if (delimiter == token::BEGIN_LIST)
+                {
+                    for (label i=0; i<len; ++i)
+                    {
+                        list[i] = list.readValue(is);
+
+                        is.fatalCheck
+                        (
+                            "PackedList::read(Istream&) : "
+                            "reading entry"
+                        );
+                    }
+                }
+                else if (delimiter == token::BEGIN_BLOCK)
+                {
+                    // Assign for all entries
+                    list = list.readValue(is);
+
+                    is.fatalCheck
+                    (
+                        "PackedList::read(Istream&) : "
+                        "reading the single entry"
+                    );
+                }
+                else
+                {
+                    FatalIOErrorInFunction(is)
+                        << "incorrect list token, expected '(' or '{', found "
+                        << firstTok.info()
+                        << exit(FatalIOError);
+                }
+            }
+
+            // Read end of contents
+            is.readEndList("PackedList");
+        }
+        else
+        {
+            if (len)
+            {
+                is.read
+                (
+                    reinterpret_cast<char*>(list.storage().data()),
+                    list.byteSize()
+                );
+
+                is.fatalCheck
+                (
+                    "PackedList::read(Istream&) : "
+                    "reading the binary block"
+                );
+            }
+        }
+    }
+    else if (firstTok.isPunctuation())
+    {
+        if (firstTok.pToken() == token::BEGIN_LIST)
+        {
+            token nextTok(is);
+            is.fatalCheck(FUNCTION_NAME);
+
+            while
+            (
+                !(   nextTok.isPunctuation()
+                  && nextTok.pToken() == token::END_LIST
+                 )
+            )
+            {
+                is.putBack(nextTok);
+                list.append(list.readValue(is));
+
+                is  >> nextTok;
+                is.fatalCheck(FUNCTION_NAME);
+            }
+        }
+        else if (firstTok.pToken() == token::BEGIN_BLOCK)
+        {
+            token nextTok(is);
+            is.fatalCheck(FUNCTION_NAME);
+
+            while
+            (
+                !(   nextTok.isPunctuation()
+                  && nextTok.pToken() == token::END_BLOCK
+                 )
+            )
+            {
+                is.putBack(nextTok);
+                list.setPair(is);
+
+                is  >> nextTok;
+                is.fatalCheck(FUNCTION_NAME);
+            }
+        }
+        else
+        {
+            FatalIOErrorInFunction(is)
+                << "incorrect first token, expected '(', found "
+                << firstTok.info()
+                << exit(FatalIOError);
+        }
+    }
+    else
+    {
+        FatalIOErrorInFunction(is)
+            << "incorrect first token, expected <int>, '(' or '{', found "
+            << firstTok.info()
+            << exit(FatalIOError);
+    }
+
+    return is;
+}
+
+
+template<unsigned Width>
+Foam::Ostream& Foam::PackedList<Width>::writeList
+(
+    Ostream& os,
+    const label shortListLen
+) const
+{
+    const PackedList<Width>& list = *this;
+    const label len = list.size();
+
+    // Write list contents depending on data format
+    if (os.format() == IOstream::ASCII)
+    {
+        if (list.uniform())
+        {
+            // Two or more entries, and all entries have identical values.
+            os  << len << token::BEGIN_BLOCK << list[0] << token::END_BLOCK;
+        }
+        else if (!shortListLen || len <= shortListLen)
+        {
+            // Shorter list, or line-breaks suppressed
+            os  << len << token::BEGIN_LIST;
+            for (label i=0; i < len; ++i)
+            {
+                if (i) os << token::SPACE;
+                os  << list[i];
+            }
+            os  << token::END_LIST;
+        }
+        else
+        {
+            // Longer list
+            os << nl << len << nl << token::BEGIN_LIST << nl;
+            for (label i=0; i < len; ++i)
+            {
+                os << list[i] << nl;
+            }
+            os << token::END_LIST << nl;
+        }
+    }
+    else
+    {
+        // Contents are binary and contiguous
+        os  << nl << len << nl;
+
+        if (len)
+        {
+            // write(...) includes surrounding start/end delimiters
+            os.write
+            (
+                reinterpret_cast<const char*>(list.storage().cdata()),
+                list.byteSize()
+            );
+        }
+    }
+
+    return os;
+}
+
+
+template<unsigned Width>
+void Foam::PackedList<Width>::writeEntry
+(
+    const word& keyword,
+    Ostream& os
+) const
+{
+    os.writeKeyword(keyword);
+    writeEntry(os);
+    os  << token::END_STATEMENT << endl;
+}
+
+
+// * * * * * * * * * * * * * *  Friend Operators * * * * * * * * * * * * * * //
+
+template<unsigned Width>
+Foam::Istream& Foam::operator>>(Istream& is, PackedList<Width>& list)
+{
+    return list.read(is);
+}
+
+
+template<unsigned Width>
+Foam::Ostream& Foam::operator<<(Ostream& os, const PackedList<Width>& list)
+{
+    return list.writeList(os, 10);
+}
+
+
+template<unsigned Width>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const InfoProxy<PackedList<Width>>& iproxy
+)
+{
+    const PackedList<Width>& list = iproxy.t_;
+
+    os  << "PackedList<" << Width
+        << "> size=" << list.size() << "/" << list.capacity()
+        << " (limits: max=" << PackedList<Width>::max_value
+        << ", elem_per_block=" << PackedList<Width>::elem_per_block
+        << ")"
+        << nl;
+
+    return os;
+}
+
+
+// ************************************************************************* //

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

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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, licensed under GNU General Public License
+    <http://www.gnu.org/licenses/>.
+
+Typedef
+    Foam::PackedBoolList
+
+Description
+    Compatibility name. Superseded (MAR-2018) by Foam::bitSet
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef PackedBoolList_H
+#define PackedBoolList_H
+
+#include "bitSet.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+     typedef bitSet PackedBoolList;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

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

@@ -0,0 +1,569 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "bitSet.H"
+#include "labelRange.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(bitSet, 0);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+Foam::bitSet& Foam::bitSet::minusEq(const bitSet& other)
+{
+    if (&other == this)
+    {
+        // Self '-=' : results in clearing all bits
+        if (debug & 2)
+        {
+            InfoInFunction
+                << "Perform -= on self: clears all bits" << nl;
+        }
+
+        reset();
+        return *this;
+    }
+    else if (empty() || other.empty())
+    {
+        return *this;
+    }
+
+
+    // The operation (on overlapping blocks)
+    {
+        const label nblocks = num_blocks(std::min(size(), other.size()));
+        const auto& rhs = other.blocks_;
+
+        for (label blocki = 0; blocki < nblocks; ++blocki)
+        {
+            blocks_[blocki] &= ~rhs[blocki];
+        }
+    }
+
+    return *this;
+}
+
+
+Foam::bitSet& Foam::bitSet::andEq(const bitSet& other)
+{
+    if (&other == this)
+    {
+        // Self '&=' : no-op
+
+        if (debug & 2)
+        {
+            InfoInFunction
+                << "Perform &= on self: ignore" << nl;
+        }
+
+        return *this;
+    }
+    else if (empty())
+    {
+        // empty set : no-op (no overlap possible)
+        return *this;
+    }
+    else if (other.empty())
+    {
+        reset();  // Other is empty - no overlap possible
+        return *this;
+    }
+
+
+    // The operation (on overlapping blocks)
+    {
+        const label nblocks = num_blocks(std::min(size(), other.size()));
+        const auto& rhs = other.blocks_;
+
+        for (label blocki = 0; blocki < nblocks; ++blocki)
+        {
+            blocks_[blocki] &= rhs[blocki];
+        }
+    }
+
+    return *this;
+}
+
+
+Foam::bitSet& Foam::bitSet::orEq(const bitSet& other, const bool strict)
+{
+    if (&other == this)
+    {
+        // Self '|=' : no-op
+
+        if (debug & 2)
+        {
+            InfoInFunction
+                << "Perform |= on self: ignore" << nl;
+        }
+
+        return *this;
+    }
+    else if (other.empty())
+    {
+        if ((debug & 2) && !empty())
+        {
+            // OK if both are empty
+            InfoInFunction
+                << "Perform |= using empty operand: ignore" << nl;
+        }
+
+        // No (normal) overlap: no-op
+        return *this;
+    }
+    else if (empty())
+    {
+        if (debug & 2)
+        {
+            InfoInFunction
+                << "Perform |= on empty bitSet" << nl;
+        }
+
+        if (strict)
+        {
+            // No (normal) overlap: no-op
+            return *this;
+        }
+    }
+    else if ((debug & 2) && (size() != other.size()))
+    {
+        InfoInFunction
+            << "Perform |= on dissimilar sized bitSets: "
+            << size()  << " vs. " << other.size() << nl;
+    }
+    {
+        return *this;
+    }
+
+    label minpos = -1; // Min trim point
+
+    if ((size() < other.size()) && !strict)
+    {
+        // The size (B > A) and we are non-strict (greedy), which means we may
+        // acquire additional bits from B. However, we would like to avoid
+        // spurious changes in the size of A (ie, B is longer but the extra
+        // bits are unset and thus don't affect the logical result).
+
+        minpos = size();
+        resize(other.size());   // Blocks now overlap
+    }
+
+
+    // The operation (on overlapping blocks)
+    {
+        const label nblocks = num_blocks(std::min(size(), other.size()));
+        const auto& rhs = other.blocks_;
+
+        for (label blocki = 0; blocki < nblocks; ++blocki)
+        {
+            blocks_[blocki] |= rhs[blocki];
+        }
+    }
+
+
+    // Cleanup - minpos >= 0 means we need to check/adjust the trim point
+    if (minpos >= 0)
+    {
+        trim(minpos); // Adjust the trim point (size)
+    }
+    else
+    {
+        clear_trailing_bits();
+    }
+
+    return *this;
+}
+
+
+Foam::bitSet& Foam::bitSet::xorEq(const bitSet& other, const bool strict)
+{
+    if (&other == this)
+    {
+        // Self '^=' : results in clearing all bits
+
+        if (debug & 2)
+        {
+            InfoInFunction
+                << "Perform ^= on self: clears all bits" << nl;
+        }
+
+        reset();
+        return *this;
+    }
+    else if (other.empty())
+    {
+        if ((debug & 2) && !empty())
+        {
+            // OK if both are empty
+            InfoInFunction
+                << "Perform ^= using empty operand: ignore" << nl;
+        }
+
+        // No (normal) overlap: no-op
+        return *this;
+    }
+    else if (empty())
+    {
+        if (debug & 2)
+        {
+            InfoInFunction
+                << "Perform ^= on empty bitSet" << nl;
+        }
+
+        if (strict)
+        {
+            // No (normal) overlap: no-op
+            return *this;
+        }
+    }
+    else if ((debug & 2) && (size() != other.size()))
+    {
+        InfoInFunction
+            << "Perform ^= on dissimilar sized bitSets: "
+            << size()  << " vs. " << other.size() << nl;
+    }
+
+    label minpos = -1; // Min trim point
+
+    if ((size() < other.size()) && !strict)
+    {
+        minpos = size();        // This logic is explained in the orEq() method
+        resize(other.size());   // Blocks now overlap
+    }
+
+
+    // The operation (on overlapping blocks)
+    {
+        const label nblocks = num_blocks(std::min(size(), other.size()));
+        const auto& rhs = other.blocks_;
+
+        for (label blocki = 0; blocki < nblocks; ++blocki)
+        {
+            blocks_[blocki] ^= rhs[blocki];
+        }
+    }
+
+
+    // Cleanup - minpos >= 0 means we need to check/adjust the trim point
+    if (minpos >= 0)
+    {
+        trim(minpos); // Adjust the trim point (size)
+    }
+    else
+    {
+        clear_trailing_bits();
+    }
+
+    return *this;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::bitSet::bitSet(Istream& is)
+:
+    PackedList<1>()
+{
+    is  >> *this;
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::bitSet::assign(const UList<bool>& bools)
+{
+    const label len = bools.size();
+
+    resize(len);
+    assign(false);
+
+    // Could also handle block-wise (in the future?)
+
+    // Set according to indices that are true.
+    for (label i = 0; i < len; ++i)
+    {
+        if (bools[i])
+        {
+            set(i);
+        }
+    }
+}
+
+
+bool Foam::bitSet::intersects(const bitSet& other) const
+{
+    if (size() && other.size())
+    {
+        const label nblocks = num_blocks(std::min(size(), other.size()));
+        const auto& rhs = other.blocks_;
+
+        for (label blocki = 0; blocki < nblocks; ++blocki)
+        {
+            if (bool(blocks_[blocki] & rhs[blocki]))
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
+void Foam::bitSet::set(const labelRange& range)
+{
+    labelRange slice(range);
+    slice.adjust();  // No negative start, size adjusted accordingly
+
+    // Range is invalid (zero-sized or entirely negative) - noop
+    if (slice.empty())
+    {
+        return;
+    }
+
+    // Range finishes at or beyond the right side.
+    // - zero fill any gaps that we might create.
+    // - flood-fill the reset, which now correponds to the full range.
+    //
+    // NB: use labelRange after() for the exclusive end-value, which
+    // corresponds to our new set size.
+    if (slice.after() >= size())
+    {
+        resize(slice.start(), false);
+        resize(slice.after(), true);
+        return;
+    }
+
+    // The more difficult case - everything in between.
+    // 1. sequence may begin/end in the same block
+    // 2. Cover more than one block
+    //    a. with partial coverage in the first block
+    //    b. with partial coverage in the end block
+
+    // The begin block/offset
+    unsigned int bblock = slice.first() / elem_per_block;
+    unsigned int bmask  = slice.first() % elem_per_block;
+
+    // The end block/offset
+    unsigned int eblock = slice.after() / elem_per_block;
+    unsigned int emask  = slice.after() % elem_per_block;
+
+    // Transform offsets to lower bit masks
+    if (bmask) bmask = mask_lower(bmask);
+    if (emask) emask = mask_lower(emask);
+
+    if (bblock == eblock)
+    {
+        // Same block - flll between the begin/end bits.
+        // Example:
+        // bmask = 0000000000001111  (lower bits)
+        // emask = 0000111111111111  (lower bits)
+        // -> set  0000111111110000  (xor)
+
+        blocks_[bblock] |= (emask^bmask);
+    }
+    else
+    {
+        if (bmask)
+        {
+            // The first (partial) block
+            // - set everything above the bmask.
+            blocks_[bblock] |= (~bmask);
+            ++bblock;
+        }
+
+        // Fill these blocks
+        for (unsigned blocki = bblock; blocki < eblock; ++blocki)
+        {
+            blocks_[blocki] = (~0u);
+        }
+
+        if (emask)
+        {
+            // The last (partial) block.
+            // - set everything below emask.
+            blocks_[eblock] |= (emask);
+        }
+    }
+}
+
+
+void Foam::bitSet::unset(const labelRange& range)
+{
+    // Require intersection with the current bitset
+    const labelRange slice = range.subset0(size());
+
+    // Range does not intersect (invalid, empty, bitset is empty)
+    if (slice.empty())
+    {
+        return;
+    }
+
+    // Range finishes at or beyond the right side.
+    //
+    // NB: use labelRange after() for the exclusive end-value, which
+    // corresponds to our new set size.
+    if (slice.after() >= size())
+    {
+        // The original size
+        const label orig = size();
+
+        resize(slice.start(), false);
+        resize(orig, false);
+        return;
+    }
+
+
+    // The more difficult case - everything in between.
+    // 1. sequence may begin/end in the same block
+    // 2. Cover more than one block
+    //    a. with partial coverage in the first block
+    //    b. with partial coverage in the end block
+
+    // The begin block/offset
+    unsigned int bblock = slice.first() / elem_per_block;
+    unsigned int bmask  = slice.first() % elem_per_block;
+
+    // The end block/offset
+    unsigned int eblock = slice.after() / elem_per_block;
+    unsigned int emask  = slice.after() % elem_per_block;
+
+    // Transform offsets to lower bit masks
+    if (bmask) bmask = mask_lower(bmask);
+    if (emask) emask = mask_lower(emask);
+
+    if (bblock == eblock)
+    {
+        // Same block - flll between the begin/end bits.
+        // Example:
+        // bmask = 0000000000001111  (lower bits)
+        // emask = 0000111111111111  (lower bits)
+        // -> set  0000111111110000  (xor)
+        // -> ~    1111000000001111
+
+        blocks_[bblock] &= (~(emask^bmask));
+    }
+    else
+    {
+        if (bmask)
+        {
+            // The first (partial) block
+            // - only retain things below bmask.
+            blocks_[bblock] &= (bmask);
+            ++bblock;
+        }
+
+        // Clear these blocks
+        for (unsigned blocki = bblock; blocki < eblock; ++blocki)
+        {
+            blocks_[blocki] = (0u);
+        }
+
+        if (emask)
+        {
+            // The last (partial) block.
+            // - only retain things above bmask.
+            blocks_[eblock] &= (~emask);
+        }
+    }
+}
+
+
+Foam::labelList Foam::bitSet::toc() const
+{
+    // Number of used (set) entries
+    const label total = any() ? count() : 0;
+
+    if (!total)
+    {
+        return labelList();
+    }
+
+    labelList output(total);
+    label nItem = 0;
+
+    // Process block-wise, detecting any '1' bits
+
+    const label nblocks = num_blocks(size());
+    for (label blocki = 0; blocki < nblocks; ++blocki)
+    {
+        unsigned int blockval = blocks_[blocki];
+
+        if (blockval)
+        {
+            for (label pos = (blocki * elem_per_block); blockval; ++pos)
+            {
+                if (blockval & 1u)
+                {
+                    output[nItem] = pos;
+                    ++nItem;
+                }
+                blockval >>= 1u;
+            }
+            if (nItem == total) break;  // Terminate early
+        }
+    }
+
+    return output;
+}
+
+
+Foam::List<bool> Foam::bitSet::values() const
+{
+    List<bool> output(size(), false);
+
+    // Process block-wise, detecting any '1' bits
+
+    const label nblocks = num_blocks(size());
+    for (label blocki = 0; blocki < nblocks; ++blocki)
+    {
+        label pos = (blocki * elem_per_block);
+
+        for
+        (
+            unsigned int blockval = blocks_[blocki];
+            blockval;
+            blockval >>= 1u
+        )
+        {
+            if (blockval & 1u)
+            {
+                output[pos] = true;
+            }
+            ++pos;
+        }
+    }
+
+    return output;
+}
+
+
+// ************************************************************************* //

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

@@ -0,0 +1,547 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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::bitSet
+
+Description
+    A bitSet stores bits (elements with only two states) in packed internal
+    format and supports a variety of bit-set operations.
+    Its behaviour is largely list-like, with some HashSet features.
+
+SourceFiles
+    bitSetI.H
+    bitSet.C
+    bitSetIO.C
+    bitSetTemplates.C
+
+See also
+    Foam::BitOps
+    Foam::PackedList
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef bitSet_H
+#define bitSet_H
+
+#include "className.H"
+#include "PackedList.H"
+#include "UIndirectList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declarations
+class bitSet;
+class labelRange;
+
+/*---------------------------------------------------------------------------*\
+                           Class bitSet Declaration
+\*---------------------------------------------------------------------------*/
+
+class bitSet
+:
+    public PackedList<1>
+{
+protected:
+
+    // Protected Member Functions
+
+        //- Write as a dictionary entry
+        void writeEntry(Ostream& os) const;
+
+    // Logic/Set Operations
+
+        //- The set difference
+        //  \code
+        //      A = (A - B)
+        //      A = (A & !B)
+        //      A = (A & ~B)
+        //  \endcode
+        //  A and B can have different sizes.
+        //  Does not change the original set size.
+        bitSet& minusEq(const bitSet& other);
+
+        //- The set logical AND
+        //  \code
+        //      A = (A & B)
+        //
+        //  \endcode
+        //  A and B can have different sizes..
+        //  Does not change the original set size.
+        bitSet& andEq(const bitSet& other);
+
+        //- The set logical OR
+        //  \code
+        //      A = (A | B)
+        //  \endcode
+        //  A and B can have different sizes
+        //
+        //  \note
+        //      The default (strict=true) ignores additional length from B,
+        //      whereas (strict=false) permits the set to automatically grow
+        //      to accommodate additional elements arising from B.
+        bitSet& orEq(const bitSet& other, const bool strict=true);
+
+        //- The set logical XOR
+        //  \code
+        //      A = (A ^ B)
+        //  \endcode
+        //  A and B can have different sizes. Sizing behaviour as per orEq.
+        bitSet& xorEq(const bitSet& other, const bool strict=true);
+
+public:
+
+    // Forward declaration of access classes
+
+        class reference;
+        class const_iterator;
+        typedef unsigned int const_reference;
+
+    //- Define class name and debug
+    ClassName("bitSet");
+
+
+    // Constructors
+
+        //- Construct an empty, zero-sized set
+        inline constexpr bitSet() noexcept;
+
+        //- Construct from Istream
+        explicit bitSet(Istream& is);
+
+        //- Construct with given size, with all bits set to 0
+        explicit inline bitSet(const label n);
+
+        //- Construct with given size and value for all elements
+        inline bitSet(const label n, const bool val);
+
+        //- Copy construct
+        inline bitSet(const bitSet& bitset);
+
+        //- Move construct
+        inline bitSet(bitSet&& bitset);
+
+        //- Construct from a list of bools
+        explicit inline bitSet(const UList<bool>& bools);
+
+        //- Construct with given size with all bits set to 0,
+        //- subsequently add specified locations as 1.
+        inline bitSet(const label n, const labelUList& locations);
+
+        //- Construct with given size with all bits set to 0,
+        //- subsequently add specified locations as 1.
+        inline bitSet(const label n, const labelUIndList& locations);
+
+        //- Construct with given size with all bits set to 0,
+        //- subsequently add specified locations as 1.
+        inline bitSet(const label n, std::initializer_list<label> locations);
+
+        //- Construct with automatic sizing (filled with 0),
+        //- and populate with specified locations as 1.
+        explicit inline bitSet(const labelUList& locations);
+
+        //- Construct with automatic sizing (filled with 0),
+        //- and populate with specified locations as 1.
+        explicit inline bitSet(const labelUIndList& locations);
+
+        //- Clone
+        inline autoPtr<bitSet> clone() const;
+
+
+    // Member Functions
+
+    // Query
+
+        //- True if all bits in this bitset are set or if the set is empty.
+        inline bool all() const;
+
+        //- True if any bits in this bitset are set.
+        inline bool any() const;
+
+        //- True if no bits in this bitset are set.
+        inline bool none() const;
+
+        //- True if there are two or more entries and all entries have
+        //- identical values.
+        inline bool uniform() const;
+
+        //- Count number of bits set.
+        inline unsigned int count() const;
+
+        //- True if any bits in the other bitset intersect (are the same).
+        //
+        //  \note Method name compatibility with boost::dynamic_bitset
+        bool intersects(const bitSet& other) const;
+
+        //- Test value at specified position, never auto-vivify entries.
+        //
+        //  \note Method name compatibility with std::bitset
+        inline bool test(const label pos) const;
+
+        //- Locate the first bit set.
+        //  \return the location or -1 if there are no bits set.
+        //
+        //  \note Method name compatibility with boost::dynamic_bitset
+        inline label find_first() const;
+
+        //- Locate the last bit set.
+        //  \return the location or -1 if there are no bits set.
+        //
+        //  \note Provided for symmetry with find_first()
+        inline label find_last() const;
+
+        //- Locate the next bit set, starting one beyond the specified position
+        //  \return the location or -1 if there are no further bits set.
+        //
+        //  \note Method name compatibility with boost::dynamic_bitset
+        inline label find_next(label pos) const;
+
+        //- The indices of the \a on bits as a sorted labelList.
+        //
+        //  \note Method name compatibility with HashSet
+        labelList toc() const;
+
+        //- The indices of the \a on bits as a sorted labelList.
+        //  This is identical to toc(), which is always sorted.
+        //
+        //  \note Method name compatibility with HashSet
+        inline labelList sortedToc() const;
+
+        //- Return the bitset values as a boolList.
+        List<bool> values() const;
+
+
+    // Assignment
+
+        //- Assign all entries to the given value.
+        inline void assign(const bool val);
+
+        //- Copy assign all entries from a list of bools.
+        void assign(const UList<bool>& bools);
+
+
+    // Setting single or multiple values
+
+        //- Single index/value assign
+        using PackedList<1>::set;
+
+        //- Set specified bits from another bitset.
+        //  The current set size may grow to accommodate any new bits
+        //  (auto-vivifies).
+        inline void set(const bitSet& bitset);
+
+        //- Set the specified range of bits specified
+        //  The current set size may grow to accommodate any new bits
+        //  (auto-vivifies).
+        //  \note this operation is generally more efficient than calling
+        //      set(pos) on individual bits.
+        void set(const labelRange& range);
+
+
+    // Unsetting single or multiple values
+
+        //- Unset a single index
+        using PackedList<1>::unset;
+
+        //- Unset (subtract) the bits specified in the other bitset, which is
+        //- a set difference corresponds to the logical operation
+        //  \code
+        //      A = (A & !B)
+        //  \endcode
+        //  The result is comparable to 'operator-='
+        //  \endcode
+        //
+        //  A and B can have different sizes.
+        //  Does not change the original set size.
+        inline bitSet& unset(const bitSet& other);
+
+        //- Unset the specified range of bits specified, never auto-vivifies.
+        //  \note this operation can be more efficient than calling
+        //      unset(pos) on individual bits.
+        void unset(const labelRange& range);
+
+
+    // Edit
+
+        //- Invert all bits in the addressable region
+        inline void flip();
+
+        //- Invert bits at the specified position.
+        //  A no-op if the position is out-of-range
+        inline void flip(const label pos);
+
+        //- Swap contents
+        inline void swap(bitSet& bitset);
+
+        //- Transfer the contents of the argument list into this list
+        //- and annul the argument list.
+        inline void transfer(bitSet& bitset);
+
+
+    // Convenience methods
+
+        //- Ensure the addressable range does not exceed maxSize.
+        //  Either decreases the size of the bitSet or is a no-op.
+        //
+        //  \code
+        //      pointField& pts = mesh.points();
+        //      bitset.bound(pts.size());
+        //
+        //      for (const label pointi : bitset)
+        //      {
+        //          pts[pointi]  ...
+        //      }
+        //  \endcode
+        inline bitSet& bound(const label maxSize);
+
+        //- Ensure the addressable range does not exceed that of other.
+        //  Either decreases the size of the bitSet or is a no-op.
+        inline bitSet& bound(const bitSet& other);
+
+        //- Ensure that minSize is covered by the bitSet.
+        //  Either increases the size of the bitSet or is a no-op.
+        inline bitSet& extend(const label minSize);
+
+        //- Ensure the bitset is addressable throughout the range of other.
+        //  Either increases the size of the bitSet or is a no-op.
+        inline bitSet& extend(const bitSet& other);
+
+        //- Set the listed locations to true.
+        //  Does auto-vivify for non-existent entries.
+        inline void setMany(const labelUList& locations);
+
+        //- Set the listed locations to true.
+        //  Does auto-vivify for non-existent entries.
+        inline void setMany(const labelUIndList& locations);
+
+        //- Set the locations listed by the iterator range,
+        //  auto-vivify entries if needed.
+        template<class InputIter>
+        void setMany(InputIter first, InputIter last);
+
+        //- Unset the listed locations, never auto-vivifies.
+        inline void unsetMany(const labelUList& locations);
+
+        //- Unset the listed locations, never auto-vivifies.
+        inline void unsetMany(const labelUIndList& locations);
+
+        //- Unset the locations listed by the iterator range,
+        //- never auto-vivify entries.
+        template<class InputIter>
+        void unsetMany(InputIter first, InputIter last);
+
+
+    // Access helpers
+
+        //- A reference supporting read/write access to an entry
+        class reference
+        :
+            public PackedList<1>::reference
+        {
+        protected:
+            friend class bitSet;        // Access for parent
+            void operator&() = delete;  // Refuse to provide its address
+
+            //- Construct by taking reference of block from within
+            //- the list and the specified index.
+            inline reference(bitSet* parent, const label index);
+
+        public:
+
+            //- Flip the bit at the position, no range-checking
+            inline void flip();
+
+            //- Value assignment
+            inline void operator=(const reference& other);
+
+            //- Value assignment
+            inline void operator=(const unsigned int val);
+
+            //- Conversion operator
+            inline operator unsigned int () const;
+        };
+
+
+    // Iteration
+
+        //- A const_iterator for iterating across \a on values
+        class const_iterator
+        {
+            friend class bitSet;
+
+            //- The parent being iterated
+            const bitSet* set_;
+
+            //- Global position of the current \a on bit
+            label pos_;
+
+            //- Construct null - an end iterator
+            inline const_iterator() noexcept;
+
+            //- Construct begin iterator
+            inline const_iterator(const bitSet* bitset);
+
+        public:
+
+            //- Return the current \a on position
+            inline label operator*() const noexcept;
+
+            //- Move to the next \a on position
+            inline const_iterator& operator++();
+
+            inline bool operator==(const const_iterator& iter) const noexcept;
+            inline bool operator!=(const const_iterator& iter) const noexcept;
+        };
+
+
+        //- Iterator set to the position of the first \a on bit
+        inline const_iterator begin() const;
+
+        //- Iterator set to the position of the first \a on bit
+        inline const_iterator cbegin() const;
+
+        //- Iterator beyond the end of the bitSet
+        inline const_iterator end() const noexcept;
+
+        //- Iterator beyond the end of the bitSet
+        inline const_iterator cend() const noexcept;
+
+
+    // Member Operators
+
+        //- Identical to get() - get value at index.
+        //  Never auto-vivify entries.
+        inline unsigned int operator[](const label i) const;
+
+        //- Non-const access to value at index.
+        //  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);
+
+        //- Complement operator.
+        //  Return a copy of the existing set with all its bits flipped.
+        inline bitSet operator~() const;
+
+        //- 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.
+        inline bitSet& operator&=(const bitSet& other);
+
+        //- Bitwise-OR operator - similar to the set() method.
+        //  The operands may have dissimilar sizes without affecting the size
+        //  of the set.
+        inline bitSet& operator|=(const bitSet& other);
+
+        //- Bitwise-XOR operator - retains unique entries.
+        //  The operands may have dissimilar sizes without affecting the size
+        //  of the set.
+        inline bitSet& operator^=(const bitSet& other);
+
+        //- Remove entries from this list - identical to the unset() method.
+        //  The operands may have dissimilar sizes without affecting the size
+        //  of the set.
+        inline bitSet& operator-=(const bitSet& other);
+
+
+    // IO
+
+        //- Write the bitSet, with line-breaks in ASCII if the size
+        //- exceeds shortListLen.
+        //  Using '0' suppresses line-breaks entirely.
+        Ostream& writeList(Ostream& os, const label shortListLen=0) const;
+
+        //- Write as a dictionary entry with keyword
+        void writeEntry(const word& keyword, Ostream& os) const;
+
+
+    // IOstream Operators
+
+        //- Return info proxy
+        InfoProxy<bitSet> info() const
+        {
+            return *this;
+        }
+
+        friend Ostream& operator<<
+        (
+            Ostream& os,
+            const InfoProxy<bitSet>& info
+        );
+
+        friend Ostream& operator<<
+        (
+            Ostream& os,
+            const bitSet& bitset
+        );
+};
+
+
+// Global Operators
+
+//- Bitwise-AND of two bitsets.
+//  See bitSet::operator&= for more details.
+inline bitSet operator&(const bitSet& a, const bitSet& b);
+
+//- Bitwise-OR of two bitsets
+//  See bitSet::operator|= for more details.
+inline bitSet operator|(const bitSet& a, const bitSet& b);
+
+//- Bitwise-XOR of two bitsets to form a unique bit-set
+//  See bitSet::operator^= for more details.
+inline bitSet operator^(const bitSet& a, const bitSet& b);
+
+//- Bitwise difference (subset) of two bitsets to form a unique bit-set
+//  See bitSet::operator-= for more details.
+inline bitSet operator-(const bitSet& a, const bitSet& b);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "bitSetI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "bitSetTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

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

@@ -0,0 +1,672 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline constexpr Foam::bitSet::bitSet() noexcept
+:
+    PackedList<1>()
+{}
+
+
+inline Foam::bitSet::bitSet(const label n)
+:
+    PackedList<1>(n)
+{}
+
+
+inline Foam::bitSet::bitSet(const label n, const bool val)
+:
+    bitSet(n)
+{
+    if (val) assign(val);
+}
+
+
+inline Foam::bitSet::bitSet(const bitSet& bitset)
+:
+    PackedList<1>(bitset)
+{}
+
+
+inline Foam::bitSet::bitSet(bitSet&& bitset)
+:
+    PackedList<1>(std::move(bitset))
+{}
+
+
+inline Foam::bitSet::bitSet(const UList<bool>& bools)
+:
+    bitSet()
+{
+    assign(bools);
+}
+
+
+inline Foam::bitSet::bitSet(const label n, const labelUList& locations)
+:
+    bitSet(n)
+{
+    setMany(locations.begin(), locations.end());
+}
+
+
+inline Foam::bitSet::bitSet(const label n, const labelUIndList& locations)
+:
+    bitSet(n)
+{
+    setMany(locations.begin(), locations.end());
+}
+
+
+inline Foam::bitSet::bitSet
+(
+    const label n,
+    std::initializer_list<label> locations
+)
+:
+    bitSet(n)
+{
+    setMany(locations.begin(), locations.end());
+}
+
+
+inline Foam::bitSet::bitSet(const labelUList& locations)
+:
+    bitSet()
+{
+    setMany(locations.begin(), locations.end());
+}
+
+
+inline Foam::bitSet::bitSet(const labelUIndList& locations)
+:
+    bitSet()
+{
+    setMany(locations.begin(), locations.end());
+}
+
+
+inline Foam::autoPtr<Foam::bitSet> Foam::bitSet::clone() const
+{
+    return autoPtr<bitSet>::New(*this);
+}
+
+
+// * * * * * * * * * * * * * * * * References * * * * * * * * * * * * * * * * //
+
+inline Foam::bitSet::reference::reference
+(
+    bitSet* parent,
+    const label index
+)
+:
+    PackedList<1>::reference(parent, index)
+{}
+
+
+inline void Foam::bitSet::reference::flip()
+{
+    const unsigned int mask = (max_value << shift_);
+    ref_ ^= mask;
+}
+
+
+inline void Foam::bitSet::reference::operator=
+(
+    const reference& other
+)
+{
+    set(other.get());
+}
+
+
+inline void Foam::bitSet::reference::operator=
+(
+    const unsigned int val
+)
+{
+    set(val);
+}
+
+
+inline Foam::bitSet::reference::operator unsigned int () const
+{
+    return get();
+}
+
+
+// * * * * * * * * * * * * * * * * Iterators * * * * * * * * * * * * * * * * //
+
+inline Foam::bitSet::const_iterator::const_iterator() noexcept
+:
+    set_(nullptr),
+    pos_(-1)
+{}
+
+
+inline Foam::bitSet::const_iterator::const_iterator(const bitSet* parent)
+:
+    set_(parent),
+    pos_(set_->find_first())
+{}
+
+
+inline Foam::label Foam::bitSet::const_iterator::operator*() const noexcept
+{
+    return pos_;
+}
+
+
+inline Foam::bitSet::const_iterator& Foam::bitSet::const_iterator::operator++()
+{
+    pos_ = set_->find_next(pos_);
+    return *this;
+}
+
+
+inline bool Foam::bitSet::const_iterator::operator==
+(
+    const const_iterator& iter
+) const noexcept
+{
+    return (iter.pos_ == pos_);
+}
+
+
+inline bool Foam::bitSet::const_iterator::operator!=
+(
+    const const_iterator& iter
+) const noexcept
+{
+    return (iter.pos_ != pos_);
+}
+
+
+inline Foam::bitSet::const_iterator Foam::bitSet::begin() const
+{
+    return const_iterator(this);
+}
+
+
+inline Foam::bitSet::const_iterator Foam::bitSet::cbegin() const
+{
+    return const_iterator(this);
+}
+
+
+inline Foam::bitSet::const_iterator Foam::bitSet::end() const noexcept
+{
+    return const_iterator();
+}
+
+
+inline Foam::bitSet::const_iterator Foam::bitSet::cend() const noexcept
+{
+    return const_iterator();
+}
+
+
+inline Foam::label Foam::bitSet::find_first() const
+{
+    // Process block-wise, detecting any '1' bits
+
+    const label nblocks = num_blocks(size());
+    for (label blocki = 0; blocki < nblocks; ++blocki)
+    {
+        label pos = (blocki * elem_per_block);
+
+        for
+        (
+            unsigned int blockval = blocks_[blocki];
+            blockval;
+            blockval >>= 1u
+        )
+        {
+            if (blockval & 1u)
+            {
+                return pos;
+            }
+            ++pos;
+        }
+    }
+
+    return -1;
+}
+
+
+inline Foam::label Foam::bitSet::find_last() const
+{
+    // Process block-wise, detecting any '1' bits
+
+    for (label blocki = num_blocks(size())-1; blocki >= 0; --blocki)
+    {
+        unsigned int blockval = blocks_[blocki];
+
+        if (blockval)
+        {
+            label pos = (blocki * elem_per_block) - 1;
+
+            while (blockval)
+            {
+                blockval >>= 1u;
+                ++pos;
+            }
+
+            return pos;
+        }
+    }
+
+    return -1;
+}
+
+
+inline Foam::label Foam::bitSet::find_next(label pos) const
+{
+    ++pos;
+    if (pos < 0 || pos >= size())
+    {
+        return -1;
+    }
+
+    // The corresponding block/offset
+    label blocki = pos / elem_per_block;
+    unsigned int off = pos % elem_per_block;
+
+    for
+    (
+        unsigned int blockval = (blocks_[blocki] >> off);
+        blockval;
+        blockval >>= 1u
+    )
+    {
+        if (blockval & 1u)
+        {
+            return pos;
+        }
+        ++pos;
+    }
+
+    // Normal block-wise search. Starting at the next block
+
+    const label nblocks = num_blocks(size());
+    for (++blocki; blocki < nblocks; ++blocki)
+    {
+        label pos = (blocki * elem_per_block);
+
+        for
+        (
+            unsigned int blockval = blocks_[blocki];
+            blockval;
+            blockval >>= 1u
+        )
+        {
+            if (blockval & 1u)
+            {
+                return pos;
+            }
+            ++pos;
+        }
+    }
+
+    return -1;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline bool Foam::bitSet::all() const
+{
+    if (empty())
+    {
+        return true;
+    }
+
+    // Use complement to change 0 <-> 1 and check if any 1's now appear
+
+    const label nblocks = num_blocks(size());
+
+    // Extra bits in the final block?
+    const unsigned int off = size() % elem_per_block;
+
+    if (!off)
+    {
+        for (label blocki=0; blocki < nblocks; ++blocki)
+        {
+            if (~(blocks_[blocki]))
+            {
+                return false;
+            }
+        }
+    }
+    else
+    {
+        for (label blocki=0; blocki < nblocks-1; ++blocki)
+        {
+            if (~(blocks_[blocki]))
+            {
+                return false;
+            }
+        }
+
+        // Verify the final block, with masking
+
+        return (!(~blocks_[nblocks-1] & mask_lower(off)));
+    }
+
+    return true;
+}
+
+
+inline bool Foam::bitSet::any() const
+{
+    if (size())
+    {
+        const label nblocks = num_blocks(size());
+
+        for (label blocki=0; blocki < nblocks; ++blocki)
+        {
+            if (blocks_[blocki]) return true;
+        }
+    }
+
+    return false;
+}
+
+
+inline bool Foam::bitSet::none() const
+{
+    return !any();
+}
+
+
+inline bool Foam::bitSet::uniform() const
+{
+    return (size() > 1 && (test(0) ? all() : none()));
+}
+
+
+inline unsigned int Foam::bitSet::count() const
+{
+    unsigned int total = 0;
+
+    const label nblocks = num_blocks(size());
+
+    for (label blocki = 0; blocki < nblocks; ++blocki)
+    {
+        total += BitOps::bit_count(blocks_[blocki]);
+    }
+
+    return total;
+}
+
+
+inline bool Foam::bitSet::test(const label pos) const
+{
+    return get(pos);
+}
+
+
+inline Foam::labelList Foam::bitSet::sortedToc() const
+{
+    return toc();
+}
+
+
+inline void Foam::bitSet::swap(bitSet& bitset)
+{
+    PackedList<1>::swap(bitset);
+}
+
+
+inline void Foam::bitSet::transfer(bitSet& bitset)
+{
+    PackedList<1>::transfer(bitset);
+}
+
+
+inline void Foam::bitSet::assign(const bool val)
+{
+    if (empty())
+    {
+        return;  // Trivial case
+    }
+
+    const label nblocks = num_blocks(size());
+
+    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);
+        }
+    }
+}
+
+
+inline void Foam::bitSet::set(const bitSet& bitset)
+{
+    orEq(bitset, false);  // Non-strict: Lets the set size grow.
+}
+
+
+inline void Foam::bitSet::setMany(const labelUList& locations)
+{
+    setMany(locations.begin(), locations.end());
+}
+
+
+inline void Foam::bitSet::setMany(const labelUIndList& locations)
+{
+    setMany(locations.begin(), locations.end());
+}
+
+
+inline void Foam::bitSet::unsetMany(const labelUList& locations)
+{
+    unsetMany(locations.begin(), locations.end());
+}
+
+
+inline void Foam::bitSet::unsetMany(const labelUIndList& locations)
+{
+    unsetMany(locations.begin(), locations.end());
+}
+
+
+inline Foam::bitSet& Foam::bitSet::unset(const bitSet& other)
+{
+    return minusEq(other);
+}
+
+
+inline void Foam::bitSet::flip()
+{
+    if (size())
+    {
+        const label nblocks = num_blocks(size());
+
+        for (label blocki=0; blocki < nblocks; ++blocki)
+        {
+            blocks_[blocki] = ~(blocks_[blocki]);
+        }
+        clear_trailing_bits();
+    }
+}
+
+
+inline void Foam::bitSet::flip(const label i)
+{
+    if (i >= 0 && i < size())
+    {
+        reference(this, i).flip();
+    }
+}
+
+
+inline Foam::bitSet& Foam::bitSet::bound(const label maxSize)
+{
+    if (maxSize < size())
+    {
+        resize(maxSize);
+    }
+
+    return *this;
+}
+
+
+inline Foam::bitSet& Foam::bitSet::bound(const bitSet& other)
+{
+    return bound(other.size());
+}
+
+
+inline Foam::bitSet& Foam::bitSet::extend(const label minSize)
+{
+    if (size() < minSize)
+    {
+        resize(minSize);
+    }
+
+    return *this;
+}
+
+
+inline Foam::bitSet& Foam::bitSet::extend(const bitSet& other)
+{
+    return extend(other.size());
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+inline unsigned int Foam::bitSet::operator[](const label i) const
+{
+    return get(i);
+}
+
+
+inline Foam::bitSet::reference Foam::bitSet::operator[](const label i)
+{
+    // Leave enabled during testing period (MAR-2018) ... and perhaps later too
+    // #ifdef FULLDEBUG
+    checkIndex(i);
+    // #endif
+    return reference(this, 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);
+    return *this;
+}
+
+
+inline Foam::bitSet& Foam::bitSet::operator=(bitSet&& bitset)
+{
+    transfer(bitset);
+    return *this;
+}
+
+
+inline Foam::bitSet Foam::bitSet::operator~() const
+{
+    bitSet result(*this);
+    result.flip();
+    return result;
+}
+
+
+inline Foam::bitSet& Foam::bitSet::operator&=(const bitSet& other)
+{
+    return andEq(other);
+}
+
+
+inline Foam::bitSet& Foam::bitSet::operator|=(const bitSet& other)
+{
+    return orEq(other);
+}
+
+
+inline Foam::bitSet& Foam::bitSet::operator^=(const bitSet& other)
+{
+    return xorEq(other);
+}
+
+
+inline Foam::bitSet& Foam::bitSet::operator-=(const bitSet& other)
+{
+    return minusEq(other);
+}
+
+
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
+
+inline Foam::bitSet Foam::operator&(const bitSet& a, const bitSet& b)
+{
+    bitSet result(a);
+    return (result &= b);
+}
+
+
+inline Foam::bitSet Foam::operator|(const bitSet& a, const bitSet& b)
+{
+    bitSet result(a);
+    return (result |= b);
+}
+
+
+inline Foam::bitSet Foam::operator^(const bitSet& a, const bitSet& b)
+{
+    bitSet result(a);
+    return (result ^= b);
+}
+
+
+inline Foam::bitSet Foam::operator-(const bitSet& a, const bitSet& b)
+{
+    bitSet result(a);
+    return (result -= b);
+}
+
+
+// ************************************************************************* //

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

@@ -0,0 +1,135 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "bitSet.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::bitSet::writeEntry(Ostream& os) const
+{
+    os  << *this;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::bitSet::writeList
+(
+    Ostream& os,
+    const label shortListLen
+) const
+{
+    const bitSet& list = *this;
+    const label len = list.size();
+
+    // Write list contents depending on data format
+    if (os.format() == IOstream::ASCII)
+    {
+        if (list.uniform())
+        {
+            // Two or more entries, and all entries have identical values.
+            os  << len << token::BEGIN_BLOCK << list[0] << token::END_BLOCK;
+        }
+        else if (!shortListLen || len <= shortListLen)
+        {
+            // Shorter list, or line-breaks suppressed
+            os  << len << token::BEGIN_LIST;
+            for (label i=0; i < len; ++i)
+            {
+                if (i) os << token::SPACE;
+                os  << list[i];
+            }
+            os  << token::END_LIST;
+        }
+        else
+        {
+            // Longer list
+            os << nl << len << nl << token::BEGIN_LIST << nl;
+            for (label i=0; i < len; ++i)
+            {
+                os << list[i] << nl;
+            }
+            os << token::END_LIST << nl;
+        }
+    }
+    else
+    {
+        // Contents are binary and contiguous
+        os  << nl << len << nl;
+
+        if (len)
+        {
+            // write(...) includes surrounding start/end delimiters
+            os.write
+            (
+                reinterpret_cast<const char*>(list.storage().cdata()),
+                list.byteSize()
+            );
+        }
+    }
+
+    return os;
+}
+
+
+void Foam::bitSet::writeEntry
+(
+    const word& keyword,
+    Ostream& os
+) const
+{
+    os.writeKeyword(keyword);
+    writeEntry(os);
+    os  << token::END_STATEMENT << endl;
+}
+
+
+// * * * * * * * * * * * * * *  Friend Operators * * * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const bitSet& bitset)
+{
+    return bitset.writeList(os, 10);
+}
+
+
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const InfoProxy<bitSet>& iproxy
+)
+{
+    const bitSet& bitset = iproxy.t_;
+
+    os  << "bitSet<" << bitSet::elem_per_block
+        << "> size=" << bitset.size() << "/" << bitset.capacity()
+        << " count=" << bitset.count()
+        << nl;
+
+    return os;
+}
+
+
+// ************************************************************************* //

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

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 <algorithm>
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class InputIter>
+void Foam::bitSet::setMany(InputIter first, InputIter last)
+{
+    // Check the max expected value first
+    const auto max = std::max_element(first, last);
+    const label len = (max != last ? (1 + *max) : 0);
+
+    if (len > 0)
+    {
+        reserve(len);
+
+        for (; first != last; ++first)
+        {
+            set(*first);
+        }
+    }
+}
+
+
+template<class InputIter>
+void Foam::bitSet::unsetMany(InputIter first, InputIter last)
+{
+    for (; first != last; ++first)
+    {
+        unset(*first);
+    }
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/containers/HashTables/HashOps/HashOps.C

@@ -24,26 +24,23 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "HashOps.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 
 #include <algorithm>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-Foam::labelHashSet Foam::HashSetOps::used(const PackedBoolList& select)
+Foam::labelHashSet Foam::HashSetOps::used(const bitSet& select)
 {
-    const label count = select.count();
+    labelHashSet output(0);
-    const label len = select.size();
 
-    labelHashSet output(2*count);
+    if (select.any())
-
-    label used = 0;
-    for (label i = 0; i < len && used < count; ++i)
     {
-        if (select[i])
+        output.resize(2*select.count());
+
+        for (label i = select.find_first(); i >= 0; i = select.find_next(i))
         {
             output.insert(i);
-            ++used;
         }
     }
 
@@ -53,11 +50,10 @@ Foam::labelHashSet Foam::HashSetOps::used(const PackedBoolList& select)
 
 Foam::labelHashSet Foam::HashSetOps::used(const UList<bool>& select)
 {
-    // We have no estimate of the size/sparsity, just assume 1/10
-
     const label len = select.size();
 
-    labelHashSet output(len/10);
+    // No idea of the sparseness, just assume 1/8
+    labelHashSet output(len/4);
 
     for (label i = 0; i < len; ++i)
     {
@@ -71,34 +67,19 @@ Foam::labelHashSet Foam::HashSetOps::used(const UList<bool>& select)
 }
 
 
-Foam::PackedBoolList Foam::HashSetOps::bitset(const labelHashSet& labels)
+Foam::bitSet Foam::HashSetOps::bitset(const labelHashSet& locations)
 {
-    auto const max = std::max_element(labels.cbegin(), labels.cend());
+    bitSet output;
-    const label len = (max.found() ? (1 + *max) : 0);
+    output.setMany(locations.begin(), locations.end());
-
-    if (len <= 0)
-    {
-        return PackedBoolList();
-    }
-
-    PackedBoolList output(len);
-
-    for (const label i : labels)
-    {
-        if (i >= 0)
-        {
-            output.set(i);
-        }
-    }
 
     return output;
 }
 
 
-Foam::List<bool> Foam::HashSetOps::bools(const labelHashSet& labels)
+Foam::List<bool> Foam::HashSetOps::bools(const labelHashSet& locations)
 {
-    auto const max = std::max_element(labels.cbegin(), labels.cend());
+    auto const max = std::max_element(locations.begin(), locations.end());
-    const label len = (max.found() ? (1 + *max) : 0);
+    const label len = (max != locations.end() ? (1 + *max) : 0);
 
     if (len <= 0)
     {
@@ -107,7 +88,7 @@ Foam::List<bool> Foam::HashSetOps::bools(const labelHashSet& labels)
 
     List<bool> output(len, false);
 
-    for (const label i : labels)
+    for (const label i : locations)
     {
         if (i >= 0)
         {

src/OpenFOAM/containers/HashTables/HashOps/HashOps.H

@@ -49,7 +49,7 @@ namespace Foam
 
 // Forward declarations
 
-class PackedBoolList;
+class bitSet;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -60,7 +60,7 @@ class PackedBoolList;
 namespace HashSetOps
 {
 
-//- Combine HashSet operation. Equivalent to 'a += b'
+//- Combine HashSet operation. Equivalent to 'a |= b'
 template<class Key=word, class Hash=string::hash>
 struct plusEqOp
 {
@@ -68,52 +68,56 @@ struct plusEqOp
 
     void operator()(value_type& a, const value_type& b) const
     {
-        a += b;
+        a |= b;
     }
 };
 
 
-//- Convert a packed list of bits to a labelHashSet of the indices used.
+//- Convert a bitset to a labelHashSet of the indices used.
 //
-//  \param selection the list for which a 'true' entry corresponds
+//  \param select the bitset for which an \a on entry corresponds
-//       to an index for be added to the labelHashSet
+//       to an index in the output labelHashSet
 //
 //  \return a labelHashSet of the selected indices
-labelHashSet used(const PackedBoolList& select);
+//
+//  This is equivalent of the following code, but more efficiently implemented.
+//  \code
+//      bitSet select = ...;
+//      return labelHashSet(select.toc());
+//  \endcode
+labelHashSet used(const bitSet& select);
 
 
 //- Convert a list of bools to a labelHashSet of the indices used.
 //
-//  \param selection the list for which a 'true' entry corresponds
+//  \param select the boolList for which a \a true entry corresponds
-//       to an index for be added to the labelHashSet
+//       to an index in the output labelHashSet
 //
 //  \return a labelHashSet of the selected indices
 labelHashSet used(const UList<bool>& select);
 
 
-//- Convert labels to a packed list of bits, with '1' for each
+//- Transform the \a on locations to a bitSet.
-//- non-negative value and '0' for all others.
 //
-//  \param labels the list of indices.
+//  \param locations the list of positions corresponding to an \a on bit.
 //
-//  \return a packed bit list of the selected indices
+//  \return a bitset
 //
-//  \note The operation discards any negative values since these are
+//  \note The operation necessarily discards any negative values since these
-//     invalid positions in the output list.
+//     are invalid positions in a bitset.
-PackedBoolList bitset(const labelHashSet& labels);
+bitSet bitset(const labelHashSet& locations);
 
 
-//- Convert labels to a list of bools, with 'true' for each
+//- Transform the \a on locations to a boolList, with \a true for each
-//- non-negative value and 'false' for all others.
+//- non-negative location and \a false for all others.
 //
-//  \param labels the list of indices.
+//  \param locations the list of positions corresponding to an \a on bit.
 //
-//  \return a bool List of the selected indices
+//  \return a boolList
 //
-//  \note The operation discards any negative values since these are
+//  \note The operation necessarily discards any negative values since these
-//     invalid positions in the output list.
+//     are invalid positions in a boolList.
-List<bool> bools(const labelHashSet& labels);
+List<bool> bools(const labelHashSet& locations);
-
 
 } // End namespace HashSetOps
 

src/OpenFOAM/containers/Lists/ListOps/ListOps.C

@@ -115,16 +115,16 @@ Foam::labelList Foam::identity(const label len, const label start)
 }
 
 
-Foam::PackedBoolList Foam::reorder
+Foam::bitSet Foam::reorder
 (
     const labelUList& oldToNew,
-    const PackedBoolList& input,
+    const bitSet& input,
     const bool prune
 )
 {
     const label len = input.size();
 
-    PackedBoolList output(len);
+    bitSet output;
     output.reserve(len);
 
     for (label i=0; i < len; ++i)
@@ -149,10 +149,6 @@ Foam::PackedBoolList Foam::reorder
         output.trim();
     }
 
-    // Verify addresses (for movable refs)
-    // Info<< "reordered in " << long(input.storage().cdata()) << nl
-    //     << "reordered out " << long(output.storage().cdata()) << nl;
-
     return output;
 }
 
@@ -160,14 +156,11 @@ Foam::PackedBoolList Foam::reorder
 void Foam::inplaceReorder
 (
     const labelUList& oldToNew,
-    PackedBoolList& input,
+    bitSet& input,
     const bool prune
 )
 {
     input = reorder(oldToNew, input, prune);
-
-    // Verify address (for movable refs)
-    // Info<< "now have " << long(input.storage().cdata()) << nl;
 }
 
 

src/OpenFOAM/containers/Lists/ListOps/ListOps.H

@@ -45,7 +45,7 @@ SourceFiles
 #include "FlatOutput.H"
 #include "labelList.H"
 #include "HashSet.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "ops.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -126,22 +126,20 @@ void inplaceReorder
 
 
 //- Reorder the elements of a list.
-//  Similar to the general templated form, but with auto-vivify
+//  Similar to the general templated form, but with auto-vivify for Bitset.
-//  for PackedBoolList.
+bitSet reorder
-PackedBoolList reorder
 (
     const labelUList& oldToNew,
-    const PackedBoolList& input,
+    const bitSet& input,
     const bool prune = false
 );
 
 //- Inplace reorder the elements of a list.
-//  Similar to the general templated form, but with auto-vivify
+//  Similar to the general templated form, but with auto-vivify for bitSet.
-//  for PackedBoolList.
 void inplaceReorder
 (
     const labelUList& oldToNew,
-    PackedBoolList& input,
+    bitSet& input,
     const bool prune = false
 );
 
@@ -456,7 +454,7 @@ template<class T>
 void setValue
 (
     UList<T>& list,
-    const PackedBoolList& locations,
+    const bitSet& locations,
     const T& val
 );
 
@@ -578,7 +576,7 @@ template<class T>
 List<T> createWithValue
 (
     const label len,
-    const PackedBoolList& locations,
+    const bitSet& locations,
     const T& val,
     const T& deflt = T()
 );

src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C

@@ -128,7 +128,7 @@ void Foam::inplaceReorder
     // the oldToNew map is unique (ie, shuffle)
 
     // Use const reference to ensure we obtain the proper operator[]
-    // on lazy lists (eg, List<bool>, PackedBoolList)
+    // on lazy lists (eg, List<bool>, PackedList)
 
     const ListType& input = inputOutput;
     const label len = input.size();
@@ -439,7 +439,7 @@ ListType Foam::subset
 {
     const label len = input.size();
 
-    // select can have a different size (eg, PackedBoolList, labelHashSet)
+    // select can have a different size (eg, bitSet, labelHashSet)
 
     ListType output(len);
     output.resize(len);   // Consistent sizing (eg, DynamicList)
@@ -468,7 +468,7 @@ void Foam::inplaceSubset
 {
     const label len = input.size();
 
-    // select can have a different size (eg, PackedBoolList, labelHashSet)
+    // select can have a different size (eg, bitSet, labelHashSet)
 
     label count = 0;
     for (label i=0; i < len; ++i)
@@ -979,22 +979,20 @@ template<class T>
 void Foam::ListOps::setValue
 (
     UList<T>& list,
-    const PackedBoolList& locations,
+    const bitSet& locations,
     const T& val
 )
 {
-    // Need improvements in PackedBoolList for more efficiency
-
     const label len = list.size();
-    const label count = locations.count();
 
-    for (label index = 0, used = 0; index < len && used < count; ++index)
+    for
+    (
+        label pos = locations.find_first();
+        pos >= 0 && pos < len;
+        pos = locations.find_next(pos)
+    )
     {
-        if (locations.test(index))
+        list[pos] = val;
-        {
-            list[index] = val;
-            ++used;
-        }
     }
 }
 
@@ -1106,7 +1104,7 @@ template<class T>
 Foam::List<T> Foam::ListOps::createWithValue
 (
     const label len,
-    const PackedBoolList& locations,
+    const bitSet& locations,
     const T& val,
     const T& deflt
 )

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

@@ -1,217 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 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 "PackedBoolList.H"
-#include "IOstreams.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-bool Foam::PackedBoolList::bitorPrepare
-(
-    const PackedBoolList& lst,
-    label& maxPackLen
-)
-{
-    const StorageList& lhs = this->storage();
-    const StorageList& rhs = lst.storage();
-
-    const label packLen1 = this->packedLength();
-    const label packLen2 = lst.packedLength();
-
-
-    // check how the lists interact and if bit trimming is needed
-    bool needTrim = false;
-    maxPackLen = packLen1;
-
-    if (packLen1 == packLen2)
-    {
-        // identical packed lengths - only resize if absolutely necessary
-        if
-        (
-            this->size() != lst.size()
-         && maxPackLen
-         && rhs[maxPackLen-1] > lhs[maxPackLen-1]
-        )
-        {
-            // second list has a higher bit set
-            // extend addressable area and use trim
-            resize(lst.size());
-            needTrim = true;
-        }
-    }
-    else if (packLen2 < packLen1)
-    {
-        // second list is shorter, this limits the or
-        maxPackLen = packLen2;
-    }
-    else
-    {
-        // second list is longer, find the highest bit set
-        for (label storeI = packLen1; storeI < packLen2; ++storeI)
-        {
-            if (rhs[storeI])
-            {
-                maxPackLen = storeI+1;
-            }
-        }
-
-        // the upper limit moved - resize for full coverage and trim later
-        if (maxPackLen > packLen1)
-        {
-            resize(maxPackLen * packing());
-            needTrim = true;
-        }
-    }
-
-    return needTrim;
-}
-
-
-template<class LabelListType>
-void Foam::PackedBoolList::setIndices(const LabelListType& indices)
-{
-    const label len = indices.size();
-
-    // No better information, just guess something from the size
-    reserve(len);
-
-    for (label i = 0; i < len; ++i)
-    {
-        set(indices[i]);
-    }
-}
-
-
-template<class LabelListType>
-void Foam::PackedBoolList::unsetIndices(const LabelListType& indices)
-{
-    const label len = indices.size();
-    for (label i = 0; i < len; ++i)
-    {
-        unset(indices[i]);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::PackedBoolList::PackedBoolList(Istream& is)
-:
-    PackedList<1>()
-{
-    is  >> *this;
-}
-
-
-// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
-
-void Foam::PackedBoolList::set(const PackedBoolList& lst)
-{
-    // extend addressable area if needed, return maximum size possible
-    label len = 0;
-    const bool needTrim = bitorPrepare(lst, len);
-
-    // operate directly with the underlying storage
-    StorageList& lhs = this->storage();
-    const StorageList& rhs = lst.storage();
-
-    for (label i = 0; i < len; ++i)
-    {
-        lhs[i] |= rhs[i];
-    }
-
-    if (needTrim)
-    {
-        trim();
-    }
-}
-
-
-void Foam::PackedBoolList::unset(const PackedBoolList& lst)
-{
-    // operate directly with the underlying storage
-    StorageList& lhs = this->storage();
-    const StorageList& rhs = lst.storage();
-
-    // overlapping storage size
-    const label len = min(this->packedLength(), lst.packedLength());
-
-    for (label i = 0; i < len; ++i)
-    {
-        lhs[i] &= ~rhs[i];
-    }
-}
-
-
-void Foam::PackedBoolList::setMany(const labelUList& indices)
-{
-    setIndices(indices);
-}
-
-
-void Foam::PackedBoolList::setMany(const labelUIndList& indices)
-{
-    setIndices(indices);
-}
-
-
-void Foam::PackedBoolList::unsetMany(const labelUList& indices)
-{
-    unsetIndices(indices);
-}
-
-
-void Foam::PackedBoolList::unsetMany(const labelUIndList& indices)
-{
-    unsetIndices(indices);
-}
-
-
-Foam::labelList Foam::PackedBoolList::used() const
-{
-    // Number of used (set) entries
-    const label cnt = this->count();
-
-    labelList lst(cnt);
-
-    if (cnt)
-    {
-        // The length of the input list
-        const label len = this->size();
-
-        for (label i=0, usedi=0; (i < len && usedi < cnt); ++i)
-        {
-            if (test(i))
-            {
-                lst[usedi++] = i;
-            }
-        }
-    }
-
-    return lst;
-}
-
-
-// ************************************************************************* //

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

@@ -1,216 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
--------------------------------------------------------------------------------
-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::PackedBoolList
-
-Description
-    A bit-packed bool list.
-
-    In addition to the obvious memory advantage over using a
-    List\<bool\>, this class also provides a number of bit-like
-    operations.
-
-SourceFiles
-    PackedBoolListI.H
-    PackedBoolList.C
-
-See also
-    Foam::PackedList
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef PackedBoolList_H
-#define PackedBoolList_H
-
-#include "PackedList.H"
-#include "UIndirectList.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration
-class PackedBoolList;
-
-//- \typedef A List of PackedBoolList
-typedef List<PackedBoolList> PackedBoolListList;
-
-/*---------------------------------------------------------------------------*\
-                       Class PackedBoolList Declaration
-\*---------------------------------------------------------------------------*/
-
-class PackedBoolList
-:
-    public PackedList<1>
-{
-    // Private Member Functions
-
-        //- Preparation, resizing before a bitor operation
-        //  returns true if the later result needs trimming
-        bool bitorPrepare(const PackedBoolList& lst, label& maxPackLen);
-
-        //- Set the listed indices. Return number of elements changed.
-        //  Does auto-vivify for non-existent entries.
-        template<class LabelListType>
-        void setIndices(const LabelListType& indices);
-
-        //- Unset the listed indices. Return number of elements changed.
-        //  Never auto-vivify entries.
-        template<class LabelListType>
-        void unsetIndices(const LabelListType& indices);
-
-public:
-
-    // Constructors
-
-        //- Construct null
-        PackedBoolList() = default;
-
-        //- Construct from Istream
-        PackedBoolList(Istream& is);
-
-        //- Construct with given size, initializes list to 0 (false)
-        explicit inline PackedBoolList(const label size);
-
-        //- Construct with given size and value for all elements
-        inline PackedBoolList(const label size, const bool val);
-
-        //- Copy construct
-        inline PackedBoolList(const PackedBoolList& lst);
-
-        //- Move construct
-        inline PackedBoolList(PackedBoolList&& lst);
-
-        //- Construct with given size and list of labels to set as true.
-        inline PackedBoolList(const label size, const labelUList& indices);
-
-        //- Construct with given size and list of labels to set as true.
-        inline PackedBoolList(const label size, const labelUIndList& indices);
-
-        //- Construct from a list of bools
-        explicit inline PackedBoolList(const UList<bool>& lst);
-
-        //- Construct from a list of labels
-        //- using the labels as indices to indicate which bits are set
-        explicit inline PackedBoolList(const labelUList& indices);
-
-        //- Construct from a list of labels
-        //- using the labels as indices to indicate which bits are set
-        explicit inline PackedBoolList(const labelUIndList& indices);
-
-        //- Clone
-        inline autoPtr<PackedBoolList> clone() const;
-
-
-    // Member Functions
-
-    // Query
-
-        //- Test value at specified position.
-        //  \note Method name compatibility with std::bitset
-        inline bool test(const label pos) const;
-
-
-    // Access
-
-        //- Single index/value assign
-        using PackedList<1>::set;
-
-        //- Single index unassign
-        using PackedList<1>::unset;
-
-        //- Set specified bits.
-        void set(const PackedBoolList& lst);
-
-        //- Unset specified bits.
-        void unset(const PackedBoolList& lst);
-
-        //- Return indices of the used (true) elements as a list of labels
-        labelList used() const;
-
-
-    // Edit
-
-        //- Transfer the contents of the argument list into this list
-        //- and annul the argument list.
-        inline void transfer(PackedBoolList& lst);
-
-
-    // Convenience Methods
-
-        //- Set the listed indices. Return number of elements changed.
-        //  Does auto-vivify for non-existent entries.
-        void setMany(const labelUList& indices);
-
-        //- Set the listed indices. Return number of elements changed.
-        //  Does auto-vivify for non-existent entries.
-        void setMany(const labelUIndList& indices);
-
-        //- Unset the listed indices. Return number of elements changed.
-        //  Never auto-vivify entries.
-        void unsetMany(const labelUList& indices);
-
-        //- Unset the listed indices. Return number of elements changed.
-        //  Never auto-vivify entries.
-        void unsetMany(const labelUIndList& indices);
-
-
-    // Member Operators
-
-        //- Assign all entries to the given value.
-        inline void operator=(const bool val);
-
-        //- Copy assignment
-        inline void operator=(const PackedBoolList& lst);
-
-        //- Move assignment
-        inline void operator=(PackedBoolList&& lst);
-
-
-    // Housekeeping
-
-        //- No assignment from list. Use setMany for that.
-        void operator=(const labelUList&) = delete;
-
-        //- No assignment from list. Use setMany for that.
-        void operator=(const labelUIndList&) = delete;
-
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "PackedBoolListI.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -1,152 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
--------------------------------------------------------------------------------
-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/>.
-
-\*---------------------------------------------------------------------------*/
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-inline Foam::PackedBoolList::PackedBoolList(const label size)
-:
-    PackedList<1>(size)
-{}
-
-
-inline Foam::PackedBoolList::PackedBoolList
-(
-    const label size,
-    const bool val
-)
-:
-    PackedList<1>(size, (val ? 1u : 0u))
-{}
-
-
-inline Foam::PackedBoolList::PackedBoolList(const PackedBoolList& lst)
-:
-    PackedList<1>(lst)
-{}
-
-
-inline Foam::PackedBoolList::PackedBoolList(PackedBoolList&& lst)
-:
-    PackedList<1>()
-{
-    transfer(lst);
-}
-
-
-inline Foam::PackedBoolList::PackedBoolList(const UList<bool>& lst)
-:
-    PackedList<1>(lst.size())
-{
-    // Set according to indices that are true
-    const label len = lst.size();
-
-    for (label i = 0; i < len; ++i)
-    {
-        if (lst[i])
-        {
-            this->set(i, 1u);
-        }
-    }
-}
-
-
-inline Foam::PackedBoolList::PackedBoolList(const labelUList& indices)
-:
-    PackedBoolList((indices.size() ? indices.last() : 0), indices)
-{}
-
-
-inline Foam::PackedBoolList::PackedBoolList(const labelUIndList& indices)
-:
-    PackedBoolList((indices.size() ? indices.last() : 0), indices)
-{}
-
-
-inline Foam::PackedBoolList::PackedBoolList
-(
-    const label size,
-    const labelUList& indices
-)
-:
-    PackedList<1>(size)
-{
-    setMany(indices);
-}
-
-
-inline Foam::PackedBoolList::PackedBoolList
-(
-    const label size,
-    const labelUIndList& indices
-)
-:
-    PackedList<1>(size)
-{
-    setMany(indices);
-}
-
-
-inline Foam::autoPtr<Foam::PackedBoolList>
-Foam::PackedBoolList::clone() const
-{
-    return autoPtr<PackedBoolList>::New(*this);
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-inline bool Foam::PackedBoolList::test(const label pos) const
-{
-    return get(pos);
-}
-
-
-inline void Foam::PackedBoolList::transfer(PackedBoolList& lst)
-{
-    PackedList<1>::transfer(static_cast<PackedList<1>&>(lst));
-}
-
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-inline void Foam::PackedBoolList::operator=(const bool val)
-{
-    PackedList<1>::operator=(val);
-}
-
-
-inline void Foam::PackedBoolList::operator=(const PackedBoolList& lst)
-{
-    PackedList<1>::operator=(lst);
-}
-
-
-inline void Foam::PackedBoolList::operator=(PackedBoolList&& lst)
-{
-    transfer(lst);
-}
-
-
-// ************************************************************************* //

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

@@ -1,536 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
--------------------------------------------------------------------------------
-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 "PackedList.H"
-#include "IOstreams.H"
-
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<unsigned nBits>
-void Foam::PackedList<nBits>::writeEntry(Ostream& os) const
-{
-    os  << *this;
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-#if (UINT_MAX == 0xFFFFFFFF)
-    // 32-bit counting, Hamming weight method
-    #define COUNT_PACKEDBITS(sum, x)                                           \
-{                                                                              \
-    x -= (x >> 1) & 0x55555555;                                                \
-    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);                            \
-    sum += (((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;                 \
-}
-#elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF)
-    // 64-bit counting, Hamming weight method
-    #define COUNT_PACKEDBITS(sum, x)                                           \
-{                                                                              \
-    x -= (x >> 1) & 0x5555555555555555;                                        \
-    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);            \
-    sum += (((x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F) * 0x0101010101010101) >> 56; \
-}
-#else
-    // Arbitrary number of bits, Brian Kernighan's method
-    #define COUNT_PACKEDBITS(sum, x)    for (; x; ++sum) { x &= x - 1; }
-#endif
-
-
-template<unsigned nBits>
-unsigned int Foam::PackedList<nBits>::count() const
-{
-    unsigned int c = 0;
-
-    if (size_)
-    {
-        const label packLen = packedLength();
-        for (label i = 0; i < packLen; ++i)
-        {
-            unsigned int bits = StorageList::operator[](i);
-            COUNT_PACKEDBITS(c, bits);
-        }
-    }
-
-    return c;
-}
-
-#undef COUNT_PACKEDBITS
-
-
-template<unsigned nBits>
-bool Foam::PackedList<nBits>::trim()
-{
-    if (!size_)
-    {
-        return false;
-    }
-
-    const label oldSize = size_;
-    for (label storeI = packedLength()-1; storeI >= 0; --storeI)
-    {
-        size_ = storeI * packing();
-        unsigned int bits = StorageList::operator[](storeI);
-
-        // found some bits
-        if (bits)
-        {
-            while (bits)
-            {
-                bits >>= nBits;
-                ++size_;
-            }
-            break;
-        }
-    }
-
-    return (size_ != oldSize);
-}
-
-
-template<unsigned nBits>
-void Foam::PackedList<nBits>::flip()
-{
-    if (!size_)
-    {
-        return;
-    }
-
-    // mask value for complete segments
-    const unsigned int mask = maskLower(packing());
-
-    const label packLen = packedLength();
-    for (label i=0; i < packLen; ++i)
-    {
-        StorageList::operator[](i) = mask & ~StorageList::operator[](i);
-    }
-
-    // mask off the final partial segment
-    {
-        const unsigned int off = size_ % packing();
-        if (off)
-        {
-            const unsigned int seg = size_ / packing();
-
-            StorageList::operator[](seg) &= maskLower(off);
-        }
-    }
-}
-
-
-template<unsigned nBits>
-Foam::labelList Foam::PackedList<nBits>::values() const
-{
-    labelList elems(size_);
-
-    for (label i=0; i < size_; ++i)
-    {
-        elems[i] = get(i);
-    }
-
-    return elems;
-}
-
-
-template<unsigned nBits>
-Foam::Ostream& Foam::PackedList<nBits>::printBits
-(
-    Ostream& os,
-    const bool fullOutput
-) const
-{
-    const label packLen = packedLength();
-
-    // mask value for complete segments
-    unsigned int mask = maskLower(packing());
-    const label outputLen = fullOutput ? StorageList::size() : packLen;
-
-    os  << "(\n";
-    for (label i=0; i < outputLen; ++i)
-    {
-        const StorageType& rawBits = StorageList::operator[](i);
-
-        // the final segment may not be full, modify mask accordingly
-        if (i == packLen-1)
-        {
-            const unsigned int off = size_ % packing();
-
-            if (off)
-            {
-                mask = maskLower(off);
-            }
-        }
-        else if (i == packLen)
-        {
-            // no mask for unaddressed bit
-            mask = 0u;
-        }
-
-
-        for (unsigned int testBit = (1u << max_bits()); testBit; testBit >>= 1)
-        {
-            if (mask & testBit)
-            {
-                // addressable region
-                if (rawBits & testBit)
-                {
-                    os  << '1';
-                }
-                else
-                {
-                    os  << '-';
-                }
-            }
-            else
-            {
-                if (rawBits & testBit)
-                {
-                    os  << '!';
-                }
-                else
-                {
-                    os  << '.';
-                }
-            }
-        }
-        os  << '\n';
-    }
-    os  << ")\n";
-
-    return os;
-}
-
-
-template<unsigned nBits>
-Foam::Ostream& Foam::PackedList<nBits>::printInfo
-(
-    Ostream& os,
-    const bool fullOutput
-) const
-{
-    os  << "PackedList<" << nBits << ">"
-        << " max_value:" << max_value()
-        << " packing:"   << packing() << nl
-        << " count: "     << count() << nl
-        << " size/capacity: " << size_ << "/" << capacity() << nl
-        << " storage/capacity: "
-        << packedLength() << "/" << StorageList::size()
-        << "\n";
-
-    return printBits(os, fullOutput);
-}
-
-
-template<unsigned nBits>
-Foam::Istream& Foam::PackedList<nBits>::read(Istream& is)
-{
-    PackedList<nBits>& lst = *this;
-
-    lst.clear();
-    is.fatalCheck(FUNCTION_NAME);
-
-    token firstTok(is);
-    is.fatalCheck
-    (
-        "PackedList::read(Istream&) : "
-        "reading first token"
-    );
-
-    if (firstTok.isLabel())
-    {
-        const label len = firstTok.labelToken();
-
-        // Set list length to that read
-        lst.resize(len);
-
-        // Read list contents depending on data format
-        if (is.format() == IOstream::ASCII)
-        {
-            // Read beginning of contents
-            const char delimiter = is.readBeginList("PackedList");
-
-            if (len)
-            {
-                if (delimiter == token::BEGIN_LIST)
-                {
-                    for (label i=0; i<len; ++i)
-                    {
-                        lst.set(i, lst.readValue(is));
-
-                        is.fatalCheck
-                        (
-                            "PackedList::read(Istream&) : "
-                            "reading entry"
-                        );
-                    }
-                }
-                else if (delimiter == token::BEGIN_BLOCK)
-                {
-                    // assign for all entries
-                    lst = lst.readValue(is);
-
-                    is.fatalCheck
-                    (
-                        "PackedList::read(Istream&) : "
-                        "reading the single entry"
-                    );
-                }
-                else
-                {
-                    FatalIOErrorInFunction(is)
-                        << "incorrect list token, expected '(' or '{', found "
-                        << firstTok.info()
-                        << exit(FatalIOError);
-                }
-            }
-
-            // Read end of contents
-            is.readEndList("PackedList");
-        }
-        else
-        {
-            if (len)
-            {
-                is.read
-                (
-                    reinterpret_cast<char*>(lst.storage().data()),
-                    lst.byteSize()
-                );
-
-                is.fatalCheck
-                (
-                    "PackedList::read(Istream&) : "
-                    "reading the binary block"
-                );
-            }
-        }
-    }
-    else if (firstTok.isPunctuation())
-    {
-        if (firstTok.pToken() == token::BEGIN_LIST)
-        {
-            token nextTok(is);
-            is.fatalCheck(FUNCTION_NAME);
-
-            while
-            (
-                !(   nextTok.isPunctuation()
-                  && nextTok.pToken() == token::END_LIST
-                 )
-            )
-            {
-                is.putBack(nextTok);
-                lst.append(lst.readValue(is));
-
-                is  >> nextTok;
-                is.fatalCheck(FUNCTION_NAME);
-            }
-        }
-        else if (firstTok.pToken() == token::BEGIN_BLOCK)
-        {
-            token nextTok(is);
-            is.fatalCheck(FUNCTION_NAME);
-
-            while
-            (
-                !(   nextTok.isPunctuation()
-                  && nextTok.pToken() == token::END_BLOCK
-                 )
-            )
-            {
-                is.putBack(nextTok);
-                lst.setPair(is);
-
-                is  >> nextTok;
-                is.fatalCheck(FUNCTION_NAME);
-            }
-        }
-        else
-        {
-            FatalIOErrorInFunction(is)
-                << "incorrect first token, expected '(', found "
-                << firstTok.info()
-                << exit(FatalIOError);
-        }
-    }
-    else
-    {
-        FatalIOErrorInFunction(is)
-            << "incorrect first token, expected <int>, '(' or '{', found "
-            << firstTok.info()
-            << exit(FatalIOError);
-    }
-
-    return is;
-}
-
-
-template<unsigned nBits>
-Foam::Ostream& Foam::PackedList<nBits>::writeList
-(
-    Ostream& os,
-    const label shortListLen
-) const
-{
-    const PackedList<nBits>& lst = *this;
-    const label len = lst.size();
-
-    // Write list contents depending on data format
-    if (os.format() == IOstream::ASCII)
-    {
-        // Can the contents be considered 'uniform' (ie, identical)?
-        bool uniform = (len > 1);
-        if (uniform)
-        {
-            forAll(lst, i)
-            {
-                if (lst[i] != lst[0])
-                {
-                    uniform = false;
-                    break;
-                }
-            }
-        }
-
-        if (uniform)
-        {
-            // uniform values:
-            os  << len << token::BEGIN_BLOCK << lst[0] << token::END_BLOCK;
-        }
-        else if (!shortListLen || len <= shortListLen)
-        {
-            // Shorter list, or line-breaks suppressed
-            os  << len << token::BEGIN_LIST;
-            forAll(lst, i)
-            {
-                if (i) os << token::SPACE;
-                os  << lst[i];
-            }
-            os  << token::END_LIST;
-        }
-        else
-        {
-            // Longer list
-            os << nl << len << nl << token::BEGIN_LIST << nl;
-            forAll(lst, i)
-            {
-                os << lst[i] << nl;
-            }
-            os << token::END_LIST << nl;
-        }
-    }
-    else
-    {
-        // Contents are binary and contiguous
-        os  << nl << len << nl;
-
-        if (len)
-        {
-            // write(...) includes surrounding start/end delimiters
-            os.write
-            (
-                reinterpret_cast<const char*>(lst.storage().cdata()),
-                lst.byteSize()
-            );
-        }
-    }
-
-    return os;
-}
-
-
-template<unsigned nBits>
-void Foam::PackedList<nBits>::writeEntry
-(
-    const word& keyword,
-    Ostream& os
-) const
-{
-    os.writeKeyword(keyword);
-    writeEntry(os);
-    os  << token::END_STATEMENT << endl;
-}
-
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-template<unsigned nBits>
-void Foam::PackedList<nBits>::operator=(const PackedList<nBits>& lst)
-{
-    StorageList::operator=(lst);
-    size_ = lst.size();
-}
-
-
-template<unsigned nBits>
-void Foam::PackedList<nBits>::operator=(PackedList<nBits>&& lst)
-{
-    transfer(lst);
-}
-
-
-template<unsigned nBits>
-void Foam::PackedList<nBits>::operator=(const labelUList& lst)
-{
-    setCapacity(lst.size());
-    size_ = lst.size();
-
-    forAll(lst, i)
-    {
-        set(i, lst[i]);
-    }
-}
-
-
-template<unsigned nBits>
-void Foam::PackedList<nBits>::operator=(const labelUIndList& lst)
-{
-    setCapacity(lst.size());
-    size_ = lst.size();
-
-    forAll(lst, i)
-    {
-        set(i, lst[i]);
-    }
-}
-
-
-// * * * * * * * * * * * * * *  Friend Operators * * * * * * * * * * * * * * //
-
-template<unsigned nBits>
-Foam::Istream& Foam::operator>>(Istream& is, PackedList<nBits>& lst)
-{
-    return lst.read(is);
-}
-
-
-template<unsigned nBits>
-Foam::Ostream& Foam::operator<<(Ostream& os, const PackedList<nBits>& lst)
-{
-    return lst.writeList(os, 10);
-}
-
-
-// ************************************************************************* //

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

@@ -1,730 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
--------------------------------------------------------------------------------
-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 <climits>
-#include "error.H"
-
-// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
-
-template<unsigned nBits>
-inline constexpr unsigned int Foam::PackedList<nBits>::max_bits()
-{
-    return sizeof(StorageType)*CHAR_BIT - 1;
-}
-
-
-template<unsigned nBits>
-inline constexpr unsigned int Foam::PackedList<nBits>::max_value()
-{
-    return (1u << nBits) - 1;
-}
-
-
-template<unsigned nBits>
-inline constexpr unsigned int Foam::PackedList<nBits>::packing()
-{
-    return sizeof(StorageType)*CHAR_BIT / nBits;
-}
-
-
-template<unsigned nBits>
-inline constexpr unsigned int Foam::PackedList<nBits>::maskLower
-(
-    unsigned offset
-)
-{
-    // Return (1u << (nBits * offset)) - 1;
-    // The next one works more reliably with overflows
-    // eg, when compiled without optimization
-    return (~0u >> (sizeof(StorageType)*CHAR_BIT - nBits * offset));
-}
-
-
-template<unsigned nBits>
-inline constexpr Foam::label Foam::PackedList<nBits>::packedLength
-(
-    const label nElem
-)
-{
-    return (nElem + packing() - 1) / packing();
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-namespace Foam
-{
-    // Template specialization for bool entries
-    template<> inline unsigned int PackedList<1>::readValue(Istream& is)
-    {
-        return readBool(is);
-    }
-
-    // Template specialization for bool entries
-    template<> inline void PackedList<1>::setPair(Istream& is)
-    {
-        set(readLabel(is), true);
-    }
-}
-
-
-template<unsigned nBits>
-inline unsigned int Foam::PackedList<nBits>::readValue(Istream& is)
-{
-    const unsigned int val = readLabel(is);
-
-    if (val > max_value())
-    {
-        FatalIOErrorInFunction(is)
-            << "Out-of-range value " << val << " for PackedList<" << nBits
-            << ">. Maximum permitted value is " << max_value() << "."
-            << exit(FatalIOError);
-    }
-
-    return val;
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::setPair(Istream& is)
-{
-    is.readBegin("Tuple2<label,unsigned int>");
-
-    const label ind = readLabel(is);
-    const unsigned int val = readLabel(is);
-
-    is.readEnd("Tuple2<label,unsigned int>");
-
-    if (val > max_value())
-    {
-        FatalIOErrorInFunction(is)
-            << "Out-of-range value " << val << " for PackedList<" << nBits
-            << "> at index " << ind
-            << ". Maximum permitted value is " << max_value() << "."
-            << exit(FatalIOError);
-    }
-
-    set(ind, val);
-
-    is.check(FUNCTION_NAME);
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList()
-:
-    PackedListCore(),
-    StorageList(),
-    size_(0)
-{}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList(const label size)
-:
-    PackedListCore(),
-    StorageList(packedLength(size), 0u),
-    size_(size)
-{}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList
-(
-    const label size,
-    const unsigned int val
-)
-:
-    PackedListCore(),
-    StorageList(packedLength(size), 0u),
-    size_(size)
-{
-    if (val)
-    {
-        operator=(val);
-    }
-}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList(Istream& is)
-:
-    PackedListCore(),
-    StorageList(),
-    size_(0)
-{
-    read(is);
-}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList(const PackedList<nBits>& lst)
-:
-    PackedListCore(),
-    StorageList(lst),
-    size_(lst.size_)
-{}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList(PackedList<nBits>&& lst)
-:
-    PackedListCore(),
-    StorageList(),
-    size_(0)
-{
-    transfer(lst);
-}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList(const labelUList& lst)
-:
-    PackedListCore(),
-    StorageList(packedLength(lst.size()), 0u),
-    size_(lst.size())
-{
-    const label len = lst.size();
-    for (label i = 0; i < len; ++i)
-    {
-        set(i, lst[i]);
-    }
-}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::PackedList(const labelUIndList& lst)
-:
-    PackedListCore(),
-    StorageList(packedLength(lst.size()), 0u),
-    size_(lst.size())
-{
-    const label len = lst.size();
-    for (label i = 0; i < len; ++i)
-    {
-        set(i, lst[i]);
-    }
-}
-
-
-template<unsigned nBits>
-inline Foam::autoPtr<Foam::PackedList<nBits>>
-Foam::PackedList<nBits>::clone() const
-{
-    return autoPtr<PackedList<nBits>>::New(*this);
-}
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::checkIndex(const label i) const
-{
-    if (!size_)
-    {
-        FatalErrorInFunction
-            << "attempt to access element " << i << " from zero sized list"
-            << abort(FatalError);
-    }
-    else if (i < 0 || i >= size_)
-    {
-        FatalErrorInFunction
-            << "index " << i << " out of range [0," << size_ << ")"
-            << abort(FatalError);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Reference  * * * * * * * * * * * * * * * * //
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::reference::reference
-(
-    PackedList* list,
-    const label index
-)
-:
-    ref_(list->StorageList::operator[](index / packing())),
-    shift_(nBits * (index % packing()))
-{}
-
-
-template<unsigned nBits>
-inline unsigned int Foam::PackedList<nBits>::reference::get() const
-{
-    return ((ref_ >> shift_) & max_value());
-}
-
-
-template<unsigned nBits>
-inline bool Foam::PackedList<nBits>::reference::set(const unsigned int val)
-{
-    const unsigned int prev = ref_;
-
-    const unsigned int mask = max_value() << shift_;
-
-    if (val >= max_value())
-    {
-        // Overflow is max_value, fill everything
-        ref_ |= mask;
-    }
-    else
-    {
-        ref_ &= ~mask;
-        ref_ |= mask & (val << shift_);
-    }
-
-    return (prev != ref_);
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::reference::operator=
-(
-    const reference& other
-)
-{
-    this->set(other.get());
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::reference::operator=
-(
-    const unsigned int val
-)
-{
-    this->set(val);
-}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>::reference::operator unsigned int () const
-{
-    return this->get();
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<unsigned nBits>
-inline Foam::label Foam::PackedList<nBits>::size() const
-{
-    return size_;
-}
-
-
-template<unsigned nBits>
-inline bool Foam::PackedList<nBits>::empty() const
-{
-    return !size_;
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::resize
-(
-    const label newSize,
-    const unsigned int val
-)
-{
-    reserve(newSize);
-
-    const label oldSize = size_;
-    size_ = newSize;
-
-    if (size_ > oldSize)
-    {
-        // Fill new elements or newly exposed elements
-        if (val)
-        {
-            // Fill value for complete segments
-            unsigned int fill = val;
-
-            if (val >= max_value())
-            {
-                // Fill everything
-                fill = maskLower(packing());
-            }
-            else
-            {
-                for (unsigned int i = 1; i < packing(); ++i)
-                {
-                    fill |= (fill << nBits);
-                }
-            }
-
-            // Fill in complete segments
-            const label oldLen = packedLength(oldSize);
-            const label newLen = packedLength(size_);
-            for (label i=oldLen; i < newLen; ++i)
-            {
-                StorageList::operator[](i) = fill;
-            }
-
-            // Finish previous partial segment, preserve existing value
-            {
-                const unsigned int off = oldSize % packing();
-                if (off)
-                {
-                    const unsigned int seg = oldSize / packing();
-                    const unsigned int mask = maskLower(off);
-
-                    StorageList::operator[](seg) &= mask;
-                    StorageList::operator[](seg) |= ~mask & fill;
-                }
-            }
-
-            // Mask off the (new) final partial segment
-            {
-                const unsigned int off = size_ % packing();
-                if (off)
-                {
-                    const unsigned int seg = size_ / packing();
-
-                    StorageList::operator[](seg) &= maskLower(off);
-                }
-            }
-        }
-    }
-    else if (size_ < oldSize)
-    {
-        // Resize shrinking
-        // - clear newly exposed elements
-
-        // Fill in complete segments
-        const label oldLen = packedLength(oldSize);
-        const label newLen = packedLength(size_);
-        for (label i=newLen; i < oldLen; ++i)
-        {
-            StorageList::operator[](i) = 0u;
-        }
-
-        // Mask off the final partial segment
-        {
-            const unsigned int off = size_ % packing();
-            if (off)
-            {
-                const unsigned int seg = size_ / packing();
-
-                StorageList::operator[](seg) &= maskLower(off);
-            }
-        }
-    }
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::setSize
-(
-    const label newSize,
-    const unsigned int val
-)
-{
-    resize(newSize, val);
-}
-
-
-template<unsigned nBits>
-inline Foam::label Foam::PackedList<nBits>::capacity() const
-{
-    return packing() * StorageList::size();
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::setCapacity(const label nElem)
-{
-    StorageList::setSize(packedLength(nElem), 0u);
-
-    // Truncate addressed size too
-    if (size_ > nElem)
-    {
-        size_ = nElem;
-
-        // Mask off the final partial segment
-        const unsigned int off = size_ % packing();
-        if (off)
-        {
-            const unsigned int seg = size_ / packing();
-
-            StorageList::operator[](seg) &= maskLower(off);
-        }
-    }
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::reserve(const label nElem)
-{
-    const label len = packedLength(nElem);
-
-    // Allocate more capacity if necessary
-    if (len > StorageList::size())
-    {
-        StorageList::setSize
-        (
-            max
-            (
-                len,
-                // SizeInc=0, SizeMult=2, SizeDiv=1
-                2 * StorageList::size()
-            ),
-            0u
-        );
-    }
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::reset()
-{
-    StorageList::operator=(0u);
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::clear()
-{
-    reset();
-    size_ = 0;
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::clearStorage()
-{
-    StorageList::clear();
-    size_ = 0;
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::shrink()
-{
-    // Any unneeded space allocated?
-    const label len = packedLength();
-    if (len < StorageList::size())
-    {
-        StorageList::setSize(len);
-    }
-}
-
-
-template<unsigned nBits>
-inline Foam::List<unsigned int>& Foam::PackedList<nBits>::storage()
-{
-    return static_cast<StorageList&>(*this);
-}
-
-
-template<unsigned nBits>
-inline const Foam::List<unsigned int>& Foam::PackedList<nBits>::storage() const
-{
-    return static_cast<const StorageList&>(*this);
-}
-
-
-template<unsigned nBits>
-inline Foam::label Foam::PackedList<nBits>::packedLength() const
-{
-    return packedLength(size_);
-}
-
-
-template<unsigned nBits>
-inline std::streamsize Foam::PackedList<nBits>::byteSize() const
-{
-    return packedLength() * sizeof(StorageType);
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::transfer(PackedList<nBits>& lst)
-{
-    size_ = lst.size_;
-    lst.size_ = 0;
-
-    StorageList::transfer(lst);
-}
-
-
-template<unsigned nBits>
-inline unsigned int Foam::PackedList<nBits>::get(const label i) const
-{
-    // Lazy evaluation - return 0 for out-of-range
-    if (i < 0 || i >= size_)
-    {
-        return 0u;
-    }
-
-    return reference(const_cast<PackedList<nBits>*>(this), i).get();
-}
-
-
-template<unsigned nBits>
-inline bool Foam::PackedList<nBits>::set
-(
-    const label i,
-    const unsigned int val
-)
-{
-    if (i < 0)
-    {
-        // Lazy evaluation - ignore out-of-bounds
-        return false;
-    }
-    else if (i >= size_)
-    {
-        if (!val)
-        {
-            // Same as unset out-of-bounds = noop
-            return false;
-        }
-
-        // Lazy evaluation - increase size on assignment
-        resize(i + 1);
-    }
-
-    return reference(this, i).set(val);
-}
-
-
-template<unsigned nBits>
-inline bool Foam::PackedList<nBits>::unset(const label i)
-{
-    // Unset out-of-bounds = noop
-    if (i < 0 || i >= size_)
-    {
-        return false;
-    }
-
-    return reference(this, i).set(0u);
-}
-
-
-template<unsigned nBits>
-inline Foam::PackedList<nBits>&
-Foam::PackedList<nBits>::append(const unsigned int val)
-{
-    const label idx = size_;
-    reserve(idx + 1);
-    size_++;
-
-    reference(this, idx).set(val);
-    return *this;
-}
-
-
-template<unsigned nBits>
-inline unsigned int Foam::PackedList<nBits>::remove()
-{
-    // Location of last element and simultaneously the new size
-    const label idx = size_ - 1;
-
-    if (idx < 0)
-    {
-        FatalErrorInFunction
-            << "List is empty" << abort(FatalError);
-    }
-
-    const unsigned int val = reference(this, idx).get();
-    resize(idx);
-
-    return val;
-}
-
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-template<unsigned nBits>
-inline unsigned int Foam::PackedList<nBits>::operator[](const label i) const
-{
-    return get(i);
-}
-
-
-template<unsigned nBits>
-inline typename Foam::PackedList<nBits>::reference
-Foam::PackedList<nBits>::operator[](const label i)
-{
-    // Leave enabled during testing period (MAR-2018)
-    // #ifdef FULLDEBUG
-    checkIndex(i);
-    // #endif
-    return reference(this, i);
-}
-
-
-template<unsigned nBits>
-inline void Foam::PackedList<nBits>::operator=(const unsigned int val)
-{
-    const label packLen = packedLength();
-
-    if (val && size_)
-    {
-        unsigned int fill = val;
-
-        if (val >= max_value())
-        {
-            // Fill everything
-            fill = maskLower(packing());
-        }
-        else
-        {
-            for (unsigned int i = 1; i < packing(); ++i)
-            {
-                fill |= (fill << nBits);
-            }
-        }
-
-        for (label i=0; i < packLen; ++i)
-        {
-            StorageList::operator[](i) = fill;
-        }
-
-        // Mask off the final partial segment
-        {
-            const unsigned int off = size_ % packing();
-            if (off)
-            {
-                const unsigned int seg = size_ / packing();
-
-                StorageList::operator[](seg) &= maskLower(off);
-            }
-        }
-    }
-    else
-    {
-        for (label i=0; i < packLen; ++i)
-        {
-            StorageList::operator[](i) = 0u;
-        }
-    }
-}
-
-
-// ************************************************************************* //

src/OpenFOAM/meshes/bandCompression/bandCompression.C

@@ -35,7 +35,7 @@ Description
 #include "IOstreams.H"
 #include "DynamicList.H"
 #include "ListOps.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -46,7 +46,7 @@ Foam::labelList Foam::bandCompression(const labelListList& cellCellAddressing)
     // the business bit of the renumbering
     SLList<label> nextCell;
 
-    PackedBoolList visited(cellCellAddressing.size());
+    bitSet visited(cellCellAddressing.size());
 
     label cellInOrder = 0;
 
@@ -171,7 +171,7 @@ Foam::labelList Foam::bandCompression
     // the business bit of the renumbering
     SLList<label> nextCell;
 
-    PackedBoolList visited(offsets.size()-1);
+    bitSet visited(offsets.size()-1);
 
     label cellInOrder = 0;
 

src/OpenFOAM/meshes/meshShapes/cell/oppositeCellFace.C

@@ -29,7 +29,7 @@ Description
 
 #include "cell.H"
 #include "oppositeFace.H"
-#include "boolList.H"
+#include "bitSet.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -136,7 +136,7 @@ Foam::oppositeFace Foam::cell::opposingFace
 
     // Get cell edges
     const edgeList e = edges(meshFaces);
-    boolList usedEdges(e.size(), false);
+    bitSet usedEdges(e.size());
 
     oppositeFace oppFace
     (
@@ -151,7 +151,7 @@ Foam::oppositeFace Foam::cell::opposingFace
         // to the slave face
         forAll(e, edgeI)
         {
-            if (!usedEdges[edgeI])
+            if (!usedEdges.test(edgeI))
             {
                 // Get the other vertex
                 label otherVertex = e[edgeI].otherVertex(masterFace[pointi]);
@@ -165,7 +165,7 @@ Foam::oppositeFace Foam::cell::opposingFace
                     {
                         if (slaveFace[slavePointi] == otherVertex)
                         {
-                            usedEdges[edgeI] = true;
+                            usedEdges.set(edgeI);
                             oppFace[pointi] = otherVertex;
 
                             break;

src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.C

@@ -27,7 +27,6 @@ License
 #include "pointBoundaryMesh.H"
 #include "pointMesh.H"
 #include "demandDrivenData.H"
-#include "boolList.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C

@@ -1187,9 +1187,9 @@ void Foam::globalMeshData::calcGlobalEdgeOrientation() const
         // Now check my edges on how they relate to the master's edgeVerts
         globalEdgeOrientationPtr_.reset
         (
-            new PackedBoolList(coupledPatch().nEdges())
+            new bitSet(coupledPatch().nEdges())
         );
-        PackedBoolList& globalEdgeOrientation = globalEdgeOrientationPtr_();
+        bitSet& globalEdgeOrientation = globalEdgeOrientationPtr_();
 
         forAll(coupledPatch().edges(), edgeI)
         {
@@ -2260,7 +2260,7 @@ const
 }
 
 
-const Foam::PackedBoolList& Foam::globalMeshData::globalEdgeOrientation() const
+const Foam::bitSet& Foam::globalMeshData::globalEdgeOrientation() const
 {
     if (!globalEdgeOrientationPtr_.valid())
     {
@@ -2439,7 +2439,7 @@ Foam::autoPtr<Foam::globalIndex> Foam::globalMeshData::mergePoints
 
     // 1. Count number of masters on my processor.
     label nMaster = 0;
-    PackedBoolList isMaster(mesh_.nPoints(), true);
+    bitSet isMaster(mesh_.nPoints(), true);
     forAll(pointSlaves, pointi)
     {
         if (masterGlobalPoint[pointi] == -1)

src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.H

@@ -90,14 +90,13 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of friend functions and operators
+// Forward declarations
-
 class polyMesh;
 class mapDistribute;
 template<class T> class EdgeMap;
 class globalIndex;
 class globalIndexAndTransform;
-class PackedBoolList;
+class bitSet;
 
 /*---------------------------------------------------------------------------*\
                       Class globalMeshData Declaration
@@ -171,7 +170,7 @@ class globalMeshData
             mutable autoPtr<globalIndex> globalEdgeNumberingPtr_;
             mutable autoPtr<labelListList> globalEdgeSlavesPtr_;
             mutable autoPtr<labelListList> globalEdgeTransformedSlavesPtr_;
-            mutable autoPtr<PackedBoolList> globalEdgeOrientationPtr_;
+            mutable autoPtr<bitSet> globalEdgeOrientationPtr_;
             mutable autoPtr<mapDistribute> globalEdgeSlavesMapPtr_;
 
 
@@ -545,7 +544,7 @@ public:
                 const labelListList& globalEdgeTransformedSlaves() const;
                 const mapDistribute& globalEdgeSlavesMap() const;
                 //- Is my edge same orientation as master edge
-                const PackedBoolList& globalEdgeOrientation() const;
+                const bitSet& globalEdgeOrientation() const;
 
             // Collocated point to collocated point
 

src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C

@@ -70,7 +70,7 @@ bool Foam::polyMesh::checkFaceOrthogonality
 
 
     // Statistics only for internal and masters of coupled faces
-    PackedBoolList isMasterFace(syncTools::getInternalOrMasterFaces(*this));
+    bitSet isMasterFace(syncTools::getInternalOrMasterFaces(*this));
 
     forAll(ortho, facei)
     {
@@ -203,7 +203,7 @@ bool Foam::polyMesh::checkFaceSkewness
     label nWarnSkew = 0;
 
     // Statistics only for all faces except slave coupled faces
-    PackedBoolList isMasterFace(syncTools::getMasterFaces(*this));
+    bitSet isMasterFace(syncTools::getMasterFaces(*this));
 
     forAll(skew, facei)
     {
@@ -518,7 +518,7 @@ bool Foam::polyMesh::checkFaceWeight
     label nSummed = 0;
 
     // Statistics only for internal and masters of coupled faces
-    PackedBoolList isMasterFace(syncTools::getInternalOrMasterFaces(*this));
+    bitSet isMasterFace(syncTools::getInternalOrMasterFaces(*this));
 
     forAll(faceWght, facei)
     {
@@ -605,7 +605,7 @@ bool Foam::polyMesh::checkVolRatio
     label nSummed = 0;
 
     // Statistics only for internal and masters of coupled faces
-    PackedBoolList isMasterFace(syncTools::getInternalOrMasterFaces(*this));
+    bitSet isMasterFace(syncTools::getInternalOrMasterFaces(*this));
 
     forAll(volRatio, facei)
     {

src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.C

@@ -62,10 +62,10 @@ void Foam::syncTools::swapBoundaryCellPositions
 }
 
 
-Foam::PackedBoolList Foam::syncTools::getMasterPoints(const polyMesh& mesh)
+Foam::bitSet Foam::syncTools::getMasterPoints(const polyMesh& mesh)
 {
-    PackedBoolList isMasterPoint(mesh.nPoints());
+    bitSet isMasterPoint(mesh.nPoints());
-    PackedBoolList donePoint(mesh.nPoints());
+    bitSet donePoint(mesh.nPoints());
 
     const globalMeshData& globalData = mesh.globalData();
     const labelList& meshPoints = globalData.coupledPatch().meshPoints();
@@ -96,7 +96,7 @@ Foam::PackedBoolList Foam::syncTools::getMasterPoints(const polyMesh& mesh)
 
     forAll(donePoint, pointi)
     {
-        if (!donePoint[pointi])
+        if (!donePoint.test(pointi))
         {
             isMasterPoint.set(pointi);
         }
@@ -106,10 +106,10 @@ Foam::PackedBoolList Foam::syncTools::getMasterPoints(const polyMesh& mesh)
 }
 
 
-Foam::PackedBoolList Foam::syncTools::getMasterEdges(const polyMesh& mesh)
+Foam::bitSet Foam::syncTools::getMasterEdges(const polyMesh& mesh)
 {
-    PackedBoolList isMasterEdge(mesh.nEdges());
+    bitSet isMasterEdge(mesh.nEdges());
-    PackedBoolList doneEdge(mesh.nEdges());
+    bitSet doneEdge(mesh.nEdges());
 
     const globalMeshData& globalData = mesh.globalData();
     const labelList& meshEdges = globalData.coupledPatchMeshEdges();
@@ -140,7 +140,7 @@ Foam::PackedBoolList Foam::syncTools::getMasterEdges(const polyMesh& mesh)
 
     forAll(doneEdge, edgeI)
     {
-        if (!doneEdge[edgeI])
+        if (!doneEdge.test(edgeI))
         {
             isMasterEdge.set(edgeI);
         }
@@ -150,9 +150,9 @@ Foam::PackedBoolList Foam::syncTools::getMasterEdges(const polyMesh& mesh)
 }
 
 
-Foam::PackedBoolList Foam::syncTools::getMasterFaces(const polyMesh& mesh)
+Foam::bitSet Foam::syncTools::getMasterFaces(const polyMesh& mesh)
 {
-    PackedBoolList isMasterFace(mesh.nFaces(), true);
+    bitSet isMasterFace(mesh.nFaces(), true);
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
@@ -177,12 +177,12 @@ Foam::PackedBoolList Foam::syncTools::getMasterFaces(const polyMesh& mesh)
 }
 
 
-Foam::PackedBoolList Foam::syncTools::getInternalOrMasterFaces
+Foam::bitSet Foam::syncTools::getInternalOrMasterFaces
 (
     const polyMesh& mesh
 )
 {
-    PackedBoolList isMasterFace(mesh.nFaces(), true);
+    bitSet isMasterFace(mesh.nFaces(), true);
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
@@ -213,12 +213,12 @@ Foam::PackedBoolList Foam::syncTools::getInternalOrMasterFaces
 }
 
 
-Foam::PackedBoolList Foam::syncTools::getInternalOrCoupledFaces
+Foam::bitSet Foam::syncTools::getInternalOrCoupledFaces
 (
     const polyMesh& mesh
 )
 {
-    PackedBoolList isMasterFace(mesh.nFaces(), true);
+    bitSet isMasterFace(mesh.nFaces(), true);
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 

src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.H

@@ -44,7 +44,7 @@ SourceFiles
 
 #include "Pstream.H"
 #include "EdgeMap.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "polyMesh.H"
 #include "coupledPolyPatch.H"
 #include "mapDistribute.H"
@@ -590,22 +590,22 @@ public:
 
             //- Get per point whether it is uncoupled or a master of a
             //  coupled set of points
-            static PackedBoolList getMasterPoints(const polyMesh&);
+            static bitSet getMasterPoints(const polyMesh&);
 
             //- Get per edge whether it is uncoupled or a master of a
             //  coupled set of edges
-            static PackedBoolList getMasterEdges(const polyMesh&);
+            static bitSet getMasterEdges(const polyMesh&);
 
             //- Get per face whether it is uncoupled or a master of a
             //  coupled set of faces
-            static PackedBoolList getMasterFaces(const polyMesh&);
+            static bitSet getMasterFaces(const polyMesh&);
 
             //- Get per face whether it is internal or a master of a
             //  coupled set of faces
-            static PackedBoolList getInternalOrMasterFaces(const polyMesh&);
+            static bitSet getInternalOrMasterFaces(const polyMesh&);
 
             //- Get per face whether it is internal or coupled
-            static PackedBoolList getInternalOrCoupledFaces(const polyMesh&);
+            static bitSet getInternalOrCoupledFaces(const polyMesh&);
 
 };
 

src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.C

@@ -435,12 +435,12 @@ Foam::label Foam::ZoneMesh<ZoneType, MeshType>::findZoneID
 
 
 template<class ZoneType, class MeshType>
-Foam::PackedBoolList Foam::ZoneMesh<ZoneType, MeshType>::findMatching
+Foam::bitSet Foam::ZoneMesh<ZoneType, MeshType>::findMatching
 (
     const keyType& key
 ) const
 {
-    PackedBoolList bitset;
+    bitSet bitset;
 
     const labelList indices = this->findIndices(key);
     forAll(indices, i)

src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.H

@@ -39,7 +39,7 @@ SourceFiles
 #include "regIOobject.H"
 #include "pointField.H"
 #include "Map.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "wordRes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -180,7 +180,7 @@ public:
         label findZoneID(const word& zoneName) const;
 
         //- Mark items (cells, faces, points) that match the zone specification
-        PackedBoolList findMatching(const keyType& key) const;
+        bitSet findMatching(const keyType& key) const;
 
         //- Clear addressing
         void clearAddressing();

src/OpenFOAM/meshes/primitiveMesh/PatchTools/PatchTools.H

@@ -55,8 +55,9 @@ SourceFiles
 namespace Foam
 {
 
+// Forward declarations
 class polyMesh;
-class PackedBoolList;
+class bitSet;
 class boundBox;
 
 /*---------------------------------------------------------------------------*\
@@ -249,7 +250,7 @@ public:
 
         labelList& p1EdgeLabels,
         labelList& p2EdgeLabels,
-        PackedBoolList& sameOrientation
+        bitSet& sameOrientation
     );
 
 

src/OpenFOAM/meshes/primitiveMesh/PatchTools/PatchToolsMatch.C

@@ -91,7 +91,7 @@ void Foam::PatchTools::matchEdges
 
     labelList& p1EdgeLabels,
     labelList& p2EdgeLabels,
-    PackedBoolList& sameOrientation
+    bitSet& sameOrientation
 )
 {
     p1EdgeLabels.setSize(p1.nEdges());

src/OpenFOAM/meshes/primitiveMesh/PatchTools/PatchToolsSearch.C

@@ -27,7 +27,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "PatchTools.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "boundBox.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -174,7 +174,7 @@ Foam::PatchTools::subsetMap
     faceMap.setSize(localFaces.size());
     pointMap.setSize(p.nPoints());
 
-    boolList pointHad(pointMap.size(), false);
+    bitSet pointHad(pointMap.size(), false);
 
     forAll(p, oldFacei)
     {
@@ -189,9 +189,8 @@ Foam::PatchTools::subsetMap
             forAll(f, fp)
             {
                 const label ptLabel = f[fp];
-                if (!pointHad[ptLabel])
+                if (pointHad.set(ptLabel))
                 {
-                    pointHad[ptLabel]  = true;
                     pointMap[pointi++] = ptLabel;
                 }
             }
@@ -222,7 +221,7 @@ void Foam::PatchTools::calcBounds
     // ourselves
     const PointField& points = p.points();
 
-    PackedBoolList pointIsUsed(points.size());
+    bitSet pointIsUsed(points.size());
 
     nPoints = 0;
     bb = boundBox::invertedBox;

src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.H

@@ -66,7 +66,8 @@ SourceFiles
 namespace Foam
 {
 
-class PackedBoolList;
+// Forward declarations
+class bitSet;
 
 /*---------------------------------------------------------------------------*\
                       Class primitiveMesh Declaration
@@ -296,7 +297,7 @@ protected:
             (
                 const vectorField& areas,
                 const bool report,
-                const PackedBoolList& internalOrCoupledFaces
+                const bitSet& internalOrCoupledFaces
             ) const;
 
             //- Check cells for closedness

src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheck.C

@@ -46,7 +46,7 @@ bool Foam::primitiveMesh::checkClosedBoundary
 (
     const vectorField& areas,
     const bool report,
-    const PackedBoolList& internalOrCoupledFaces
+    const bitSet& internalOrCoupledFaces
 ) const
 {
     if (debug)
@@ -1684,7 +1684,7 @@ bool Foam::primitiveMesh::checkFaceFaces
 
 bool Foam::primitiveMesh::checkClosedBoundary(const bool report) const
 {
-    return checkClosedBoundary(faceAreas(), report, PackedBoolList());
+    return checkClosedBoundary(faceAreas(), report, bitSet());
 }
 
 

src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshTools.C

@@ -455,7 +455,7 @@ Foam::tmp<Foam::scalarField> Foam::primitiveMeshTools::cellDeterminant
     const primitiveMesh& mesh,
     const Vector<label>& meshD,
     const vectorField& faceAreas,
-    const PackedBoolList& internalOrCoupledFace
+    const bitSet& internalOrCoupledFace
 )
 {
     // Determine number of dimensions and (for 2D) missing dimension

src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshTools.H

@@ -35,7 +35,7 @@ SourceFiles
 #define primitiveMeshTools_H
 
 #include "primitiveMesh.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -125,7 +125,7 @@ public:
         const primitiveMesh& mesh,
         const Vector<label>& directions,
         const vectorField& faceAreas,
-        const PackedBoolList& internalOrCoupledFace
+        const bitSet& internalOrCoupledFace
     );
 
 

src/conversion/ccm/reader/ccmReaderMesh.C

@@ -35,7 +35,7 @@ License
 #include "uindirectPrimitivePatch.H"
 #include "SortableList.H"
 #include "mergePoints.H"
-#include "PackedBoolList.H"
+#include "bitSet.H"
 #include "ListOps.H"
 
 #include "ccmInternal.H" // include last to avoid any strange interactions
@@ -1099,7 +1099,7 @@ void Foam::ccm::reader::juggleSolids()
     // Identify solid cells
     // ~~~~~~~~~~~~~~~~~~~~
     label nSolids = 0;
-    boolList solidCells(cellTableId_.size(), false);
+    bitSet solidCells(cellTableId_.size(), false);
     {
         Map<word> solidMap = cellTable_.solids();
 
@@ -1107,7 +1107,7 @@ void Foam::ccm::reader::juggleSolids()
         {
             if (solidMap.found(cellTableId_[cellI]))
             {
-                solidCells[cellI] = true;
+                solidCells.set(cellI);
                 ++nSolids;
             }
         }
@@ -1130,7 +1130,7 @@ void Foam::ccm::reader::juggleSolids()
         label faceI = patchStarts[patchIndex] + i;
         label cellI = faceOwner_[faceI];
 
-        if (solidCells[cellI])
+        if (solidCells.test(cellI))
         {
             ++adjustPatch;
         }
@@ -1186,7 +1186,7 @@ void Foam::ccm::reader::juggleSolids()
         label faceI = patchStarts[patchIndex] + i;
         label cellI = faceOwner_[faceI];
 
-        if (solidCells[cellI])
+        if (solidCells.test(cellI))
         {
             oldToNew[faceI] = solidFace++;
         }
@@ -1213,7 +1213,7 @@ void Foam::ccm::reader::removeUnwanted()
     // Identify fluid/porous/solid cells for removal
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     label nRemove = 0;
-    boolList removeCells(cellTableId_.size(), false);
+    bitSet removeCells(cellTableId_.size(), false);
 
     {
         Map<word> fluidMap  = cellTable_.fluids();
@@ -1236,7 +1236,7 @@ void Foam::ccm::reader::removeUnwanted()
               : false
             )
             {
-                removeCells[cellI] = true;
+                removeCells.set(cellI);
                 ++nRemove;
                 removeMap.set(tableId, cellTable_.name(tableId));
             }
@@ -1291,7 +1291,7 @@ void Foam::ccm::reader::removeUnwanted()
     for (label faceI = 0; faceI < nFaces_; ++faceI)
     {
         label cellI = faceOwner_[faceI];
-        if (removeCells[cellI])
+        if (removeCells.test(cellI))
         {
             if (faceI < nInternalFaces_)
             {
@@ -1356,7 +1356,7 @@ void Foam::ccm::reader::removeUnwanted()
     oldToNew.setSize(nCells_, -1);
     for (label cellI = 0; cellI < nCells_; ++cellI)
     {
-        if (!removeCells[cellI])
+        if (!removeCells.test(cellI))
         {
             if (nCell != cellI)
             {
@@ -1886,7 +1886,7 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
     label nMergedTotal = 0;
 
     // Markup points to merge
-    PackedBoolList whichPoints(points_.size());
+    bitSet whichPoints(points_.size());
 
     Info<< "interface merge points (tol="
         << option().mergeTol() << "):" << endl;
@@ -1923,7 +1923,7 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
         }
 
         // The global addresses
-        labelList addr(whichPoints.used());
+        labelList addr(whichPoints.toc());
 
         const UIndirectList<point> pointsToMerge(points_, addr);
 

src/conversion/ensight/mesh/ensightMesh.C

@@ -222,7 +222,7 @@ void Foam::ensightMesh::correct()
     if (option().useFaceZones())
     {
         // Mark boundary faces to be excluded from export
-        PackedBoolList excludeFace(mesh_.nFaces()); // all false
+        bitSet excludeFace(mesh_.nFaces()); // all false
 
         forAll(mesh_.boundaryMesh(), patchi)
         {

src/conversion/polyDualMesh/polyDualMesh.C

@@ -32,6 +32,7 @@ InClass
 #include "Time.H"
 #include "SortableList.H"
 #include "pointSet.H"
+#include "bitSet.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -594,7 +595,7 @@ void Foam::polyDualMesh::dualPatch
     // 3 : done both
     labelList doneEdgeSide(meshEdges.size(), 0);
 
-    boolList donePoint(patch.nPoints(), false);
+    bitSet donePoint(patch.nPoints(), false);
 
 
     // Do points on edge of patch
@@ -650,7 +651,7 @@ void Foam::polyDualMesh::dualPatch
                     dualRegion.append(patch.index());
 
                     doneEdgeSide[patchEdgeI] |= bitMask;
-                    donePoint[pointi] = true;
+                    donePoint.set(pointi);
                 }
             }
         }
@@ -663,7 +664,7 @@ void Foam::polyDualMesh::dualPatch
 
     forAll(donePoint, pointi)
     {
-        if (!donePoint[pointi])
+        if (!donePoint.test(pointi))
         {
             labelList dualFace, featEdgeIndices;
 
@@ -1496,7 +1497,7 @@ void Foam::polyDualMesh::calcFeatures
     const vectorField& faceNormals = allBoundary.faceNormals();
     const labelList& meshPoints = allBoundary.meshPoints();
 
-    boolList isFeatureEdge(edgeFaces.size(), false);
+    bitSet isFeatureEdge(edgeFaces.size(), false);
 
     forAll(edgeFaces, edgeI)
     {
@@ -1514,11 +1515,11 @@ void Foam::polyDualMesh::calcFeatures
                 << " has more than 2 faces connected to it:"
                 << eFaces.size() << endl;
 
-            isFeatureEdge[edgeI] = true;
+            isFeatureEdge.set(edgeI);
         }
         else if (allRegion[eFaces[0]] != allRegion[eFaces[1]])
         {
-            isFeatureEdge[edgeI] = true;
+            isFeatureEdge.set(edgeI);
         }
         else if
         (
@@ -1526,7 +1527,7 @@ void Foam::polyDualMesh::calcFeatures
           < featureCos
         )
         {
-            isFeatureEdge[edgeI] = true;
+            isFeatureEdge.set(edgeI);
         }
     }
 
@@ -1546,9 +1547,9 @@ void Foam::polyDualMesh::calcFeatures
 
         forAll(pEdges, i)
         {
-            if (isFeatureEdge[pEdges[i]])
+            if (isFeatureEdge.test(pEdges[i]))
             {
-                nFeatEdges++;
+                ++nFeatEdges;
             }
         }
         if (nFeatEdges > 2)
@@ -1593,7 +1594,7 @@ void Foam::polyDualMesh::calcFeatures
     DynamicList<label> allFeatureEdges(isFeatureEdge.size());
     forAll(isFeatureEdge, edgeI)
     {
-        if (isFeatureEdge[edgeI])
+        if (isFeatureEdge.test(edgeI))
         {
             // Store in mesh edge label.
             allFeatureEdges.append(meshEdges[edgeI]);

src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C

@@ -46,7 +46,7 @@ namespace Foam
 
 Foam::label Foam::dynamicRefineFvMesh::count
 (
-    const PackedBoolList& l,
+    const bitSet& l,
     const unsigned int val
 )
 {
@@ -72,7 +72,7 @@ Foam::label Foam::dynamicRefineFvMesh::count
 
 void Foam::dynamicRefineFvMesh::calculateProtectedCells
 (
-    PackedBoolList& unrefineableCell
+    bitSet& unrefineableCell
 ) const
 {
     if (protectedCell_.empty())
@@ -426,7 +426,7 @@ Foam::dynamicRefineFvMesh::refine
     // Update numbering of protectedCell_
     if (protectedCell_.size())
     {
-        PackedBoolList newProtectedCell(nCells());
+        bitSet newProtectedCell(nCells());
 
         forAll(newProtectedCell, celli)
         {
@@ -589,7 +589,7 @@ Foam::dynamicRefineFvMesh::unrefine
     // Update numbering of protectedCell_
     if (protectedCell_.size())
     {
-        PackedBoolList newProtectedCell(nCells());
+        bitSet newProtectedCell(nCells());
 
         forAll(newProtectedCell, celli)
         {
@@ -692,7 +692,7 @@ void Foam::dynamicRefineFvMesh::selectRefineCandidates
     const scalar lowerRefineLevel,
     const scalar upperRefineLevel,
     const scalarField& vFld,
-    PackedBoolList& candidateCell
+    bitSet& candidateCell
 ) const
 {
     // Get error per cell. Is -1 (not to be refined) to >0 (to be refined,
@@ -725,7 +725,7 @@ Foam::labelList Foam::dynamicRefineFvMesh::selectRefineCells
 (
     const label maxCells,
     const label maxRefinement,
-    const PackedBoolList& candidateCell
+    const bitSet& candidateCell
 ) const
 {
     // Every refined cell causes 7 extra cells
@@ -735,7 +735,7 @@ Foam::labelList Foam::dynamicRefineFvMesh::selectRefineCells
 
     // Mark cells that cannot be refined since they would trigger refinement
     // of protected cells (since 2:1 cascade)
-    PackedBoolList unrefineableCell;
+    bitSet unrefineableCell;
     calculateProtectedCells(unrefineableCell);
 
     // Count current selection
@@ -806,7 +806,7 @@ Foam::labelList Foam::dynamicRefineFvMesh::selectRefineCells
 Foam::labelList Foam::dynamicRefineFvMesh::selectUnrefinePoints
 (
     const scalar unrefineLevel,
-    const PackedBoolList& markedCell,
+    const bitSet& markedCell,
     const scalarField& pFld
 ) const
 {
@@ -819,7 +819,7 @@ Foam::labelList Foam::dynamicRefineFvMesh::selectUnrefinePoints
     // If we have any protected cells make sure they also are not being
     // unrefined
 
-    PackedBoolList protectedPoint(nPoints());
+    bitSet protectedPoint(nPoints());
 
     if (protectedCell_.size())
     {
@@ -911,7 +911,7 @@ Foam::labelList Foam::dynamicRefineFvMesh::selectUnrefinePoints
 
 void Foam::dynamicRefineFvMesh::extendMarkedCells
 (
-    PackedBoolList& markedCell
+    bitSet& markedCell
 ) const
 {
     // Mark faces using any marked cell
@@ -953,7 +953,7 @@ void Foam::dynamicRefineFvMesh::extendMarkedCells
 
 void Foam::dynamicRefineFvMesh::checkEightAnchorPoints
 (
-    PackedBoolList& protectedCell,
+    bitSet& protectedCell,
     label& nProtected
 ) const
 {
@@ -1277,7 +1277,7 @@ bool Foam::dynamicRefineFvMesh::update()
             readLabel(refineDict.lookup("nBufferLayers"));
 
         // Cells marked for refinement or otherwise protected from unrefinement.
-        PackedBoolList refineCell(nCells());
+        bitSet refineCell(nCells());
 
         // Determine candidates for refinement (looking at field only)
         selectRefineCandidates
@@ -1318,7 +1318,7 @@ bool Foam::dynamicRefineFvMesh::update()
                     const labelList& cellMap = map().cellMap();
                     const labelList& reverseCellMap = map().reverseCellMap();
 
-                    PackedBoolList newRefineCell(cellMap.size());
+                    bitSet newRefineCell(cellMap.size());
 
                     forAll(cellMap, celli)
                     {