Special handling for polyMesh/boundary file

applications/utilities/preProcessing/changeDictionary/changeDictionary.C

@@ -44,16 +44,24 @@ Description
     }
     @endverbatim
 
+
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
 #include "IOobjectList.H"
+#include "IOPtrList.H"
 #include "volFields.H"
 
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+namespace Foam
+{
+    defineTemplateTypeNameAndDebug(IOPtrList<entry>, 0);
+}
+
+
 
 // Main program:
 
@@ -89,38 +97,110 @@ int main(int argc, char *argv[])
         const word& fieldName = fieldIter().keyword();
         Info<< "Replacing entries in dictionary " << fieldName << endl;
 
-        // Read dictionary. (disable class type checking so we can load field)
+        // Handle 'boundary' specially:
-        Info<< "Loading dictionary " << fieldName << endl;
+        // - is PtrList of dictionaries
-        const word oldTypeName = IOdictionary::typeName;
+        // - is in polyMesh/
-        const_cast<word&>(IOdictionary::typeName) = word::null;
+        if (fieldName == "boundary")
-        IOdictionary fieldDict
+        {
-        (
+            Info<< "Special handling of " << fieldName
-            IOobject
+                << " as polyMesh/boundary file." << endl;
+
+            // Read PtrList of dictionary as dictionary.
+            const word oldTypeName = IOPtrList<entry>::typeName;
+            const_cast<word&>(IOPtrList<entry>::typeName) = word::null;
+            IOPtrList<entry> dictList
             (
-                fieldName,
+                IOobject
-                runTime.timeName(),
+                (
-                mesh,
+                    fieldName,
-                IOobject::MUST_READ,
+                    runTime.findInstance(polyMesh::meshSubDir, fieldName),
-                IOobject::NO_WRITE,
+                    polyMesh::meshSubDir,
-                false
+                    mesh,
-            )
+                    IOobject::MUST_READ,
-        );
+                    IOobject::NO_WRITE,
-        const_cast<word&>(IOdictionary::typeName) = oldTypeName;
+                    false
-        // Fake type back to what was in field
+                )
-        const_cast<word&>(fieldDict.type()) = fieldDict.headerClassName();
+            );
+            const_cast<word&>(IOPtrList<entry>::typeName) = oldTypeName;
+            // Fake type back to what was in field
+            const_cast<word&>(dictList.type()) = dictList.headerClassName();
 
-        Info<< "Loaded dictionary " << fieldName
+            // Temporary convert to dictionary
-            << " with entries " << fieldDict.toc() << endl;
+            dictionary fieldDict;
+            forAll(dictList, i)
+            {
+                fieldDict.add(dictList[i].keyword(), dictList[i].dict());
+            }
 
-        // Get the replacement dictionary for the field
+            Info<< "Loaded dictionary " << fieldName
-        const dictionary& replaceDict = fieldIter().dict();
+                << " with entries " << fieldDict.toc() << endl;
-        Info<< "Merging entries from " << replaceDict.toc() << endl;
 
-        // Merge the replacements in
+            // Get the replacement dictionary for the field
-        fieldDict.merge(replaceDict);
+            const dictionary& replaceDict = fieldIter().dict();
+            Info<< "Merging entries from " << replaceDict.toc() << endl;
 
-        Info<< "Writing modified fieldDict " << fieldName << endl;
+            // Merge the replacements in
-        fieldDict.regIOobject::write();
+            fieldDict.merge(replaceDict);
+
+            Info<< "fieldDict:" << fieldDict << endl;
+
+            // Convert back into dictList
+            wordList doneKeys(dictList.size());
+
+            label nEntries = fieldDict.size();
+            forAll(dictList, i)
+            {
+                doneKeys[i] = dictList[i].keyword();
+                dictList.set(i, fieldDict.lookupEntry(doneKeys[i]).clone());
+                fieldDict.remove(doneKeys[i]);
+            }
+            // Add remaining entries
+            label sz = dictList.size();
+            dictList.setSize(nEntries);
+            forAllConstIter(dictionary, fieldDict, iter)
+            {
+                dictList.set(sz, iter().clone());
+            }
+
+            Info<< "Writing modified fieldDict " << fieldName << endl;
+            dictList.write();
+        }
+        else
+        {
+            // Read dictionary. (disable class type checking so we can load
+            // field)
+            Info<< "Loading dictionary " << fieldName << endl;
+            const word oldTypeName = IOdictionary::typeName;
+            const_cast<word&>(IOdictionary::typeName) = word::null;
+            IOdictionary fieldDict
+            (
+                IOobject
+                (
+                    fieldName,
+                    runTime.timeName(),
+                    mesh,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            );
+            const_cast<word&>(IOdictionary::typeName) = oldTypeName;
+            // Fake type back to what was in field
+            const_cast<word&>(fieldDict.type()) = fieldDict.headerClassName();
+
+            Info<< "Loaded dictionary " << fieldName
+                << " with entries " << fieldDict.toc() << endl;
+
+            // Get the replacement dictionary for the field
+            const dictionary& replaceDict = fieldIter().dict();
+            Info<< "Merging entries from " << replaceDict.toc() << endl;
+
+            // Merge the replacements in
+            fieldDict.merge(replaceDict);
+
+            Info<< "Writing modified fieldDict " << fieldName << endl;
+            fieldDict.regIOobject::write();
+        }
     }
 
     Info<< endl;