STYLE: prefer isHeaderClass<Type>() check instead of Type::typeName

- use typeHeaderOk<regIOobject>(false) for some generic file existence checks. Often had something like labelIOField as a placeholder, but that may be construed to have a particular something.
2025-11-28 03:28:01 +00:00 · 2023-05-12 10:08:17 +02:00
parent bdd384c767
commit f41d1879b9
15 changed files with 80 additions and 84 deletions
--- a/applications/utilities/miscellaneous/foamFormatConvert/foamFormatConvert.C
+++ b/applications/utilities/miscellaneous/foamFormatConvert/foamFormatConvert.C
@ -218,7 +218,7 @@ bool writeOptionalMeshObject
    );

    bool writeOk = false;
-    const bool haveFile = io.typeHeaderOk<IOField<label>>(false);
+    const bool haveFile = io.typeHeaderOk<regIOobject>(false);

    // Make sure all know if there is a valid class name
    wordList classNames(1, io.headerClassName());
@ -375,41 +375,41 @@ int main(int argc, char *argv[])

        forAllConstIters(objects, iter)
        {
-            const word& headerClassName = (*iter)->headerClassName();
+            const IOobject& io = *(iter.val());

            if
            (
-                headerClassName == volScalarField::typeName
-             || headerClassName == volVectorField::typeName
-             || headerClassName == volSphericalTensorField::typeName
-             || headerClassName == volSymmTensorField::typeName
-             || headerClassName == volTensorField::typeName
+                io.isHeaderClass<volScalarField>()
+             || io.isHeaderClass<volVectorField>()
+             || io.isHeaderClass<volSphericalTensorField>()
+             || io.isHeaderClass<volSymmTensorField>()
+             || io.isHeaderClass<volTensorField>()

-             || headerClassName == surfaceScalarField::typeName
-             || headerClassName == surfaceVectorField::typeName
-             || headerClassName == surfaceSphericalTensorField::typeName
-             || headerClassName == surfaceSymmTensorField::typeName
-             || headerClassName == surfaceTensorField::typeName
+             || io.isHeaderClass<surfaceScalarField>()
+             || io.isHeaderClass<surfaceVectorField>()
+             || io.isHeaderClass<surfaceSphericalTensorField>()
+             || io.isHeaderClass<surfaceSymmTensorField>()
+             || io.isHeaderClass<surfaceTensorField>()

-             || headerClassName == pointScalarField::typeName
-             || headerClassName == pointVectorField::typeName
-             || headerClassName == pointSphericalTensorField::typeName
-             || headerClassName == pointSymmTensorField::typeName
-             || headerClassName == pointTensorField::typeName
+             || io.isHeaderClass<pointScalarField>()
+             || io.isHeaderClass<pointVectorField>()
+             || io.isHeaderClass<pointSphericalTensorField>()
+             || io.isHeaderClass<pointSymmTensorField>()
+             || io.isHeaderClass<pointTensorField>()

-             || headerClassName == volScalarField::Internal::typeName
-             || headerClassName == volVectorField::Internal::typeName
-             || headerClassName == volSphericalTensorField::Internal::typeName
-             || headerClassName == volSymmTensorField::Internal::typeName
-             || headerClassName == volTensorField::Internal::typeName
+             || io.isHeaderClass<volScalarField::Internal>()
+             || io.isHeaderClass<volVectorField::Internal>()
+             || io.isHeaderClass<volSphericalTensorField::Internal>()
+             || io.isHeaderClass<volSymmTensorField::Internal>()
+             || io.isHeaderClass<volTensorField::Internal>()
            )
            {
-                Info<< "        Reading " << headerClassName
-                    << " : " << (*iter)->name() << endl;
+                Info<< "        Reading " << io.headerClassName()
+                    << " : " << io.name() << endl;

-                fieldDictionary fDict(*iter(), headerClassName);
+                fieldDictionary fDict(io, io.headerClassName());

-                Info<< "        Writing " << (*iter)->name() << endl;
+                Info<< "        Writing " << io.name() << endl;
                fDict.regIOobject::write();
            }
        }
--- a/applications/utilities/miscellaneous/foamHelp/helpTypes/helpBoundary/helpBoundaryTemplates.C
+++ b/applications/utilities/miscellaneous/foamHelp/helpTypes/helpBoundary/helpBoundaryTemplates.C
@ -39,9 +39,9 @@ Foam::wordList Foam::helpTypes::helpBoundary::fieldConditions
    const bool write
 ) const
 {
-    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
+    typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;

-    if (io.headerClassName() == fieldType::typeName)
+    if (io.isHeaderClass<VolFieldType>())
    {
        wordList types
        (
@ -74,6 +74,8 @@ void Foam::helpTypes::helpBoundary::fixedValueFieldConditions
    const IOobject& io
 ) const
 {
+    typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
+
    wordList types(fieldConditions<Type>(io, false));

    if (!types.size())
@ -81,11 +83,9 @@ void Foam::helpTypes::helpBoundary::fixedValueFieldConditions
        return;
    }

-    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
-
    const fvMesh& mesh = dynamic_cast<const fvMesh&>(io.db());

-    fieldType fld
+    VolFieldType fld
    (
        IOobject
        (
--- a/applications/utilities/miscellaneous/patchSummary/patchSummaryTemplates.C
+++ b/applications/utilities/miscellaneous/patchSummary/patchSummaryTemplates.C
@ -39,7 +39,7 @@ void Foam::addToFieldList
    const typename GeoField::Mesh& mesh
 )
 {
-    if (obj.headerClassName() == GeoField::typeName)
+    if (obj.isHeaderClass<GeoField>())
    {
        fieldList.set
        (
--- a/applications/utilities/postProcessing/lagrangian/steadyParticleTracks/steadyParticleTracks.C
+++ b/applications/utilities/postProcessing/lagrangian/steadyParticleTracks/steadyParticleTracks.C
@ -107,12 +107,12 @@ IOobjectList preFilterFields
            if
            (
                //OR: fieldTypes::basic.found(io.headerClassName())
-                io.headerClassName() == IOField<label>::typeName
-             || io.headerClassName() == IOField<scalar>::typeName
-             || io.headerClassName() == IOField<vector>::typeName
-             || io.headerClassName() == IOField<sphericalTensor>::typeName
-             || io.headerClassName() == IOField<symmTensor>::typeName
-             || io.headerClassName() == IOField<tensor>::typeName
+                io.isHeaderClass<IOField<label>>()
+             || io.isHeaderClass<IOField<scalar>>()
+             || io.isHeaderClass<IOField<vector>>()
+             || io.isHeaderClass<IOField<sphericalTensor>>()
+             || io.isHeaderClass<IOField<symmTensor>>()
+             || io.isHeaderClass<IOField<tensor>>()
            )
            {
                // Transfer from cloudObjects -> filteredObjects
--- a/applications/utilities/postProcessing/lumped/lumpedPointForces/lumpedPointForces.C
+++ b/applications/utilities/postProcessing/lumped/lumpedPointForces/lumpedPointForces.C
@ -52,9 +52,9 @@ autoPtr<GeoFieldType> loadField
    const IOobject* io
 )
 {
-    if (io && io->headerClassName() == GeoFieldType::typeName)
+    if (io && io->isHeaderClass<GeoFieldType>())
    {
-        Info<< "Reading " << GeoFieldType::typeName
+        Info<< "Reading " << io->headerClassName()
            << ' ' << io->name() << endl;

        return autoPtr<GeoFieldType>::New
--- a/applications/utilities/preProcessing/setExprBoundaryFields/readFields.H
+++ b/applications/utilities/preProcessing/setExprBoundaryFields/readFields.H
@ -121,15 +121,14 @@ class readFieldsHandler
                (
                    fieldName,
                    mesh_.time().timeName(),
-                    mesh_,
+                    mesh_.thisDb(),
                    IOobject::MUST_READ,
                    IOobject::NO_WRITE
                );

                const bool ok =
                (
-                    io.typeHeaderOk<regIOobject>(false) // Preload header info
-                 && io.hasHeaderClass()                 // Extra safety
+                    io.typeHeaderOk<regIOobject>(false)
                 &&
                    (
                        loadField<scalar>(io)
--- a/applications/utilities/preProcessing/setExprFields/readFields.H
+++ b/applications/utilities/preProcessing/setExprFields/readFields.H
@ -121,15 +121,14 @@ class readFieldsHandler
                (
                    fieldName,
                    mesh_.time().timeName(),
-                    mesh_,
+                    mesh_.thisDb(),
                    IOobject::MUST_READ,
                    IOobject::NO_WRITE
                );

                const bool ok =
                (
-                    io.typeHeaderOk<regIOobject>(false) // Preload header info
-                 && io.hasHeaderClass()                 // Extra safety
+                    io.typeHeaderOk<regIOobject>(false)
                 &&
                    (
                        loadField<scalar>(io)
--- a/applications/utilities/preProcessing/setExprFields/setExprFields.C
+++ b/applications/utilities/preProcessing/setExprFields/setExprFields.C
@ -270,9 +270,8 @@ void evaluate
            IOobject::MUST_READ,
            IOobject::NO_WRITE
        );
-        io.typeHeaderOk<IOobject>(false);

-        if (!io.hasHeaderClass() || io.isHeaderClass<IOobject>())
+        if (!io.typeHeaderOk<regIOobject>(false))
        {
            FatalErrorInFunction
                << "Field '" << fieldName