ENH: use typed lookup versions instead of xyz::typeName literals

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -829,16 +829,16 @@ int main(int argc, char *argv[])
 
             if
             (
-                obj.headerClassName() == volScalarField::typeName
+                obj.isHeaderClass<volScalarField>()
-             || obj.headerClassName() == volVectorField::typeName
+             || obj.isHeaderClass<volVectorField>()
-             || obj.headerClassName() == volSphericalTensorField::typeName
+             || obj.isHeaderClass<volSphericalTensorField>()
-             || obj.headerClassName() == volTensorField::typeName
+             || obj.isHeaderClass<volTensorField>()
-             || obj.headerClassName() == volSymmTensorField::typeName
+             || obj.isHeaderClass<volSymmTensorField>()
-             || obj.headerClassName() == surfaceScalarField::typeName
+             || obj.isHeaderClass<surfaceScalarField>()
-             || obj.headerClassName() == surfaceVectorField::typeName
+             || obj.isHeaderClass<surfaceVectorField>()
-             || obj.headerClassName() == surfaceSphericalTensorField::typeName
+             || obj.isHeaderClass<surfaceSphericalTensorField>()
-             || obj.headerClassName() == surfaceSymmTensorField::typeName
+             || obj.isHeaderClass<surfaceSymmTensorField>()
-             || obj.headerClassName() == surfaceTensorField::typeName
+             || obj.isHeaderClass<surfaceTensorField>()
             )
             {
                 objects.add(objPtr);

applications/utilities/mesh/manipulation/setSet/setSet.C

@@ -153,6 +153,33 @@ void printHelp(Ostream& os)
 }
 
 
+template<class SetType>
+void printSets(Ostream& os, const IOobjectList& objects)
+{
+    label n = 0;
+
+    for (const IOobject& io : objects.sorted<SetType>())
+    {
+        SetType set(io);
+        if (!n++) os << SetType::typeName << "s:" << nl;
+        os  << '\t' << set.name() << "\tsize:" << set.size() << endl;
+    }
+}
+
+
+template<class ZoneType>
+void printZones(Ostream& os, const ZoneMesh<ZoneType, polyMesh>& zones)
+{
+    label n = 0;
+
+    for (const ZoneType& zn : zones)
+    {
+        if (!n++) os << ZoneType::typeName << "s:" << nl;
+        os  << '\t' << zn.name() << "\tsize:" << zn.size() << endl;
+    }
+}
+
+
 void printAllSets(const polyMesh& mesh, Ostream& os)
 {
     IOobjectList objects
@@ -167,64 +194,14 @@ void printAllSets(const polyMesh& mesh, Ostream& os)
         ),
         polyMesh::meshSubDir/"sets"
     );
-    IOobjectList cellSets(objects.lookupClass(cellSet::typeName));
-    if (cellSets.size())
-    {
-        os  << "cellSets:" << endl;
-        forAllConstIters(cellSets, iter)
-        {
-            cellSet set(*iter());
-            os  << '\t' << set.name() << "\tsize:" << set.size() << endl;
-        }
-    }
-    IOobjectList faceSets(objects.lookupClass(faceSet::typeName));
-    if (faceSets.size())
-    {
-        os  << "faceSets:" << endl;
-        forAllConstIters(faceSets, iter)
-        {
-            faceSet set(*iter());
-            os  << '\t' << set.name() << "\tsize:" << set.size() << endl;
-        }
-    }
-    IOobjectList pointSets(objects.lookupClass(pointSet::typeName));
-    if (pointSets.size())
-    {
-        os  << "pointSets:" << endl;
-        forAllConstIters(pointSets, iter)
-        {
-            pointSet set(*iter());
-            os  << '\t' << set.name() << "\tsize:" << set.size() << endl;
-        }
-    }
 
-    const cellZoneMesh& cellZones = mesh.cellZones();
+    printSets<cellSet>(os, objects);
-    if (cellZones.size())
+    printSets<faceSet>(os, objects);
-    {
+    printSets<pointSet>(os, objects);
-        os  << "cellZones:" << endl;
+
-        for (const cellZone& zone : cellZones)
+    printZones(os, mesh.cellZones());
-        {
+    printZones(os, mesh.faceZones());
-            os  << '\t' << zone.name() << "\tsize:" << zone.size() << endl;
+    printZones(os, mesh.pointZones());
-        }
-    }
-    const faceZoneMesh& faceZones = mesh.faceZones();
-    if (faceZones.size())
-    {
-        os  << "faceZones:" << endl;
-        for (const faceZone& zone : faceZones)
-        {
-            os  << '\t' << zone.name() << "\tsize:" << zone.size() << endl;
-        }
-    }
-    const pointZoneMesh& pointZones = mesh.pointZones();
-    if (pointZones.size())
-    {
-        os  << "pointZones:" << endl;
-        for (const pointZone& zone : pointZones)
-        {
-            os  << '\t' << zone.name() << "\tsize:" << zone.size() << endl;
-        }
-    }
 
     os  << endl;
 }

applications/utilities/mesh/manipulation/setsToZones/setsToZones.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -105,14 +105,10 @@ int main(int argc, char *argv[])
         << endl;
 
 
-    IOobjectList pointObjects(objects.lookupClass(pointSet::typeName));
+    for (const IOobject& io : objects.sorted<pointSet>())
-
-    //Pout<< "pointSets:" << pointObjects.names() << endl;
-
-    forAllConstIters(pointObjects, iter)
     {
         // Not in memory. Load it.
-        pointSet set(*iter());
+        pointSet set(io);
         labelList pointLabels(set.sortedToc());
 
         // The original number of zones
@@ -139,16 +135,12 @@ int main(int argc, char *argv[])
     }
 
 
-    IOobjectList faceObjects(objects.lookupClass(faceSet::typeName));
-
     wordHashSet slaveCellSets;
 
-    //Pout<< "faceSets:" << faceObjects.names() << endl;
+    for (const IOobject& io : objects.sorted<faceSet>())
-
-    forAllConstIters(faceObjects, iter)
     {
         // Not in memory. Load it.
-        faceSet set(*iter());
+        faceSet set(io);
         labelList faceLabels(set.sortedToc());
 
         DynamicList<label> addressing(set.size());
@@ -267,16 +259,12 @@ int main(int argc, char *argv[])
 
 
 
-    IOobjectList cellObjects(objects.lookupClass(cellSet::typeName));
+    for (const IOobject& io : objects.sorted<cellSet>())
-
-    //Pout<< "cellSets:" << cellObjects.names() << endl;
-
-    forAllConstIters(cellObjects, iter)
     {
-        if (!slaveCellSets.found(iter.key()))
+        if (!slaveCellSets.found(io.name()))
         {
             // Not in memory. Load it.
-            cellSet set(*iter());
+            cellSet set(io);
             labelList cellLabels(set.sortedToc());
 
             // The original number of zones

applications/utilities/postProcessing/dataConversion/foamDataToFluent/foamDataToFluent.C

@@ -116,11 +116,7 @@ int main(int argc, char *argv[])
 
 
         // volScalarField
-        for
+        for (const word& fieldName : objects.sortedNames<volScalarField>())
-        (
-            const word& fieldName
-          : objects.sortedNames(volScalarField::typeName)
-        )
         {
             // Lookup field from dictionary and convert field
             label unitNumber;
@@ -140,11 +136,7 @@ int main(int argc, char *argv[])
 
 
         // volVectorField
-        for
+        for (const word& fieldName : objects.sortedNames<volVectorField>())
-        (
-            const word& fieldName
-          : objects.sortedNames(volVectorField::typeName)
-        )
         {
             // Lookup field from dictionary and convert field
             label unitNumber;

applications/utilities/preProcessing/setExprBoundaryFields/readFields.H

@@ -65,7 +65,7 @@ class readFieldsHandler
         template<class FieldType>
         bool loadAndStore(const IOobject& io)
         {
-            if (FieldType::typeName == io.headerClassName())
+            if (io.isHeaderClass<FieldType>())
             {
                 // Store field on mesh database
                 Log << "    Reading " << io.name()

applications/utilities/preProcessing/setExprFields/readFields.H

@@ -65,7 +65,7 @@ class readFieldsHandler
         template<class FieldType>
         bool loadAndStore(const IOobject& io)
         {
-            if (FieldType::typeName == io.headerClassName())
+            if (io.isHeaderClass<FieldType>())
             {
                 // Store field on mesh database
                 Log << "    Reading " << io.name()

src/fileFormats/vtk/read/vtkUnstructuredReaderTemplates.C

@@ -33,7 +33,7 @@ License
 template<class Type>
 void Foam::vtkUnstructuredReader::printFieldStats(const objectRegistry& obj)
 {
-    const wordList fieldNames(obj.names(Type::typeName));
+    const wordList fieldNames(obj.sortedNames<Type>());
 
     if (fieldNames.size())
     {

src/finiteVolume/expressions/base/fvExprDriver.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2010-2018 Bernhard Gschaider
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -593,15 +593,15 @@ Foam::expressions::fvExprDriver::topoSetType(const word& setName) const
 {
     IOobject io(topoSet::findIOobject(mesh(), setName));
 
-    if (cellSet::typeName == io.headerClassName())
+    if (io.isHeaderClass<cellSet>())
     {
         return topoSetSource::sourceType::CELLSET_SOURCE;
     }
-    if (faceSet::typeName == io.headerClassName())
+    if (io.isHeaderClass<faceSet>())
     {
         return topoSetSource::sourceType::FACESET_SOURCE;
     }
-    if (pointSet::typeName == io.headerClassName())
+    if (io.isHeaderClass<pointSet>())
     {
         return topoSetSource::sourceType::POINTSET_SOURCE;
     }

src/finiteVolume/expressions/base/fvExprDriverIO.C

@@ -121,7 +121,7 @@ Foam::expressions::fvExprDriver::getTopoSetLabels
         {
             typedef cellSet classType;
 
-            if (classType::typeName != io.headerClassName())
+            if (!io.isHeaderClass<classType>())
             {
                 FatalErrorInFunction
                     << "Error reading " << classType::typeName
@@ -139,7 +139,7 @@ Foam::expressions::fvExprDriver::getTopoSetLabels
         {
             typedef faceSet classType;
 
-            if (classType::typeName != io.headerClassName())
+            if (!io.isHeaderClass<classType>())
             {
                 FatalErrorInFunction
                     << "Error reading " << classType::typeName
@@ -157,7 +157,7 @@ Foam::expressions::fvExprDriver::getTopoSetLabels
         {
             typedef pointSet classType;
 
-            if (classType::typeName != io.headerClassName())
+            if (!io.isHeaderClass<classType>())
             {
                 FatalErrorInFunction
                     << "Error reading " << classType::typeName

src/functionObjects/field/expressions/fvExpressionField.C

@@ -131,7 +131,7 @@ void doCorrectBoundaryConditions
 template<class FieldType>
 bool Foam::functionObjects::fvExpressionField::loadAndStore(const IOobject& io)
 {
-    if (FieldType::typeName == io.headerClassName())
+    if (io.isHeaderClass<FieldType>())
     {
         // Store field on mesh database
         Log << "    Reading " << io.name()

src/functionObjects/field/streamLine/streamLineBase.C

@@ -167,10 +167,10 @@ void Foam::functionObjects::streamLineBase::initInterpolations
         {
             FatalErrorInFunction
                 << "Cannot find field " << fieldName << nl
-                << "Valid scalar fields are:"
+                << "Valid scalar fields: "
-                << flatOutput(mesh_.names(volScalarField::typeName)) << nl
+                << flatOutput(mesh_.sortedNames<volScalarField>()) << nl
-                << "Valid vector fields are:"
+                << "Valid vector fields: "
-                << flatOutput(mesh_.names(volVectorField::typeName))
+                << flatOutput(mesh_.sortedNames<volVectorField>()) << nl
                 << exit(FatalError);
         }
     }

src/meshTools/topoSet/cellSources/fieldToCell/fieldToCell.C

@@ -198,11 +198,11 @@ void Foam::fieldToCell::applyToSet
             << "Cannot read field " << fieldName_
             << " from time " << mesh().time().timeName() << endl;
     }
-    // Note: should use volScalarField::typeName instead below
-    //       but that would introduce linkage problems (finiteVolume needs
-    //       meshTools)
     else if ("volScalarField" == fieldObject.headerClassName())
     {
+        // Note: cannot use volScalarField::typeName since that would
+        //    introduce linkage problems (finiteVolume needs meshTools)
+
         IFstream str(typeFilePath<labelIOList>(fieldObject));
 
         // Read as dictionary
@@ -214,6 +214,9 @@ void Foam::fieldToCell::applyToSet
     }
     else if ("volVectorField" == fieldObject.headerClassName())
     {
+        // Note: cannot use volVectorField::typeName since that would
+        //    introduce linkage problems (finiteVolume needs meshTools)
+
         IFstream str(typeFilePath<labelIOList>(fieldObject));
 
         // Read as dictionary