foamDictionary: New utility to print and manipulate dictionary entries

Replaces the dictionary access functionality of foamInfoExec and
provides additional options to edit individual entries.
Contributed by Mattijs Janssens

applications/utilities/miscellaneous/foamDebugSwitches/foamDebugSwitches.C

@@ -159,8 +159,6 @@ int main(int argc, char *argv[])
         Info<< "OptimisationSwitches: " << currOpt << endl;
     }
 
-
-
     Info<< "done" << endl;
 
     return 0;

applications/utilities/miscellaneous/foamDictionary/Make/files

+foamDictionary.C
+
+EXE = $(FOAM_USER_APPBIN)/foamDictionary

applications/utilities/miscellaneous/foamDictionary/Make/options

+EXE_INC = \
+    -DFULLDEBUG -g -O0
+
+/* EXE_LIBS = */

applications/utilities/miscellaneous/foamDictionary/foamDictionary.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Application
+    foamDictionary
+
+Description
+    Interrogates and manipulates dictionaries.
+
+Usage
+    - foamDictionary [OPTION] dictionary
+
+    \param -entry \<name\> \n
+    Selects an entry
+
+    \param -keywords \<name\> \n
+    Prints the keywords (of the selected entry or of the top level if
+    no entry was selected
+
+    \param -add \<value\> \n
+    Adds the entry (should not exist yet)
+
+    \param -set \<value\> \n
+    Adds or replaces the entry
+
+    Typical usage:
+    - change simulation to run for one timestep only:
+    foamDictionary system/controlDict -entry stopAt -set writeNow;
+
+    - change solver
+    foamDictionary system/fvSolution -entry solvers.p.solver -set PCG
+
+    - print bc type
+    foamDictionary 0/U -entry boundaryField.movingWall.type
+
+    - change bc parameter
+    foamDictionary 0/U -entry boundaryField.movingWall.value \
+        -set "uniform (2 0 0)"
+
+    - change whole bc type
+    foamDictionary 0/U -entry boundaryField.movingWall \
+        -set "{type uniformFixedValue; uniformValue (2 0 0);}"
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "IFstream.H"
+#include "OFstream.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Converts old scope syntax to new syntax
+word scope(const fileName& entryName)
+{
+    if (entryName.find(':') != string::npos)
+    {
+        wordList entryNames(entryName.components(':'));
+
+        word entry(entryNames[0]);
+        for (label i = 1; i < entryNames.size(); i++)
+        {
+            entry += word('.') + entryNames[i];
+        }
+        return entry;
+    }
+    else
+    {
+        return entryName;
+    }
+}
+
+
+//- Extract keyword (last bit of scoped name
+word keyword(const word& scopedName)
+{
+    word key(scopedName);
+    string::size_type i = scopedName.find_last_of(".");
+    if (i != string::npos)
+    {
+        key = scopedName.substr(i+1, string::npos);
+    }
+    return key;
+}
+
+
+void setScoped
+(
+    dictionary& dict,
+    const word& keyword,
+    const bool overwrite,
+    entry* d
+)
+{
+    if (keyword[0] == ':')
+    {
+        // Go up to top level and recurse to find entries
+        setScoped
+        (
+            const_cast<dictionary&>(dict.topDict()),
+            keyword.substr(1, keyword.size()-1),
+            overwrite,
+            d
+        );
+        return;
+    }
+    else
+    {
+        string::size_type dotPos = keyword.find('.');
+
+        if (dotPos == string::npos)
+        {
+            // Non-scoped lookup
+            if (overwrite)
+            {
+                dict.set(d);
+            }
+            else
+            {
+                dict.add(d, false);
+            }
+            return;
+        }
+        else
+        {
+            if (dotPos == 0)
+            {
+                // Starting with a '.'. Go up for every 2nd '.' found
+
+                const dictionary* dictPtr = &dict;
+
+                string::size_type begVar = dotPos + 1;
+                string::const_iterator iter =
+                    keyword.begin() + begVar;
+                string::size_type endVar = begVar;
+                while
+                (
+                    iter != keyword.end()
+                 && *iter == '.'
+                )
+                {
+                    ++iter;
+                    ++endVar;
+
+                    // Go to parent
+                    if (&dictPtr->parent() == &dictionary::null)
+                    {
+                        FatalIOErrorInFunction(dict)
+                            << "No parent of current dictionary"
+                            << " when searching for "
+                            <<  keyword.substr
+                                (
+                                    begVar,
+                                    keyword.size() - begVar
+                                )
+                            << exit(FatalIOError);
+                    }
+                    dictPtr = &dictPtr->parent();
+                }
+
+                setScoped
+                (
+                    const_cast<dictionary&>(*dictPtr),
+                    keyword.substr(endVar),
+                    overwrite,
+                    d
+                );
+                return;
+            }
+            else
+            {
+                // Extract the first word
+                word firstWord = keyword.substr(0, dotPos);
+
+                const entry* entPtr = dict.lookupScopedEntryPtr
+                (
+                    firstWord,
+                    false,          // Recursive
+                    false
+                );
+
+                if (!entPtr || !entPtr->isDict())
+                {
+                    FatalIOErrorInFunction(dict)
+                        << "keyword " << firstWord
+                        << " is undefined in dictionary "
+                        << dict.name() << " or is not a dictionary"
+                        << endl
+                        << "Valid keywords are " << dict.keys()
+                        << exit(FatalIOError);
+                }
+
+                const dictionary& firstDict = entPtr->dict();
+
+                setScoped
+                (
+                    const_cast<dictionary&>(firstDict),
+                    keyword.substr(dotPos, keyword.size()-dotPos),
+                    overwrite,
+                    d
+                );
+                return;
+            }
+        }
+    }
+}
+
+
+int main(int argc, char *argv[])
+{
+    argList::addNote("manipulates dictionaries");
+
+    argList::noBanner();
+    argList::validArgs.append("dictionary");
+    argList::addBoolOption("keywords", "report keywords");
+    argList::addOption("entry", "name", "report/select the named entry");
+    argList::addOption
+    (
+        "set",
+        "value",
+        "changes existing entry or adds new entry"
+    );
+    argList::addOption
+    (
+        "add",
+        "value",
+        "adds a new entry"
+    );
+
+    #include "setRootCase.H"
+
+    fileName dictFileName(args.rootPath()/args.caseName()/args[1]);
+
+    autoPtr<IFstream> dictFile(new IFstream(dictFileName));
+
+    if (dictFile().good())
+    {
+        bool changed = false;
+
+        // Read but preserve headers
+        dictionary dict;
+        dict.read(dictFile(), true);
+
+        word entryName;
+        if (args.optionReadIfPresent("entry", entryName))
+        {
+            word scopedName(scope(entryName));
+
+            string newValue;
+            if
+            (
+                args.optionReadIfPresent("set", newValue)
+             || args.optionReadIfPresent("add", newValue)
+            )
+            {
+                bool overwrite = args.optionFound("set");
+
+                word key(keyword(scopedName));
+
+                IStringStream str(string(key) + ' ' + newValue + ';');
+                setScoped(dict, scopedName, overwrite, entry::New(str).ptr());
+                changed = true;
+
+                // Print the changed entry
+                const entry* entPtr = dict.lookupScopedEntryPtr
+                (
+                    scopedName,
+                    false,
+                    true            // Support wildcards
+                );
+                if (entPtr)
+                {
+                    Info<< *entPtr << endl;
+                }
+            }
+            else
+            {
+                const entry* entPtr = dict.lookupScopedEntryPtr
+                (
+                    scopedName,
+                    false,
+                    true            // Support wildcards
+                );
+
+                if (entPtr)
+                {
+                    if (args.optionFound("keywords"))
+                    {
+                        const dictionary& dict = entPtr->dict();
+                        forAllConstIter(dictionary, dict, iter)
+                        {
+                            Info<< iter().keyword() << endl;
+                        }
+                    }
+                    else
+                    {
+                        Info<< *entPtr << endl;
+                    }
+                }
+                else
+                {
+                    FatalIOErrorInFunction(dictFile)
+                        << "Cannot find entry " << entryName
+                        << exit(FatalError, 2);
+                }
+            }
+        }
+        else if (args.optionFound("keywords"))
+        {
+            forAllConstIter(dictionary, dict, iter)
+            {
+                Info<< iter().keyword() << endl;
+            }
+        }
+        else
+        {
+            Info<< dict;
+        }
+
+        if (changed)
+        {
+            dictFile.clear();
+            OFstream os(dictFileName);
+            IOobject::writeBanner(os);
+            dict.write(os, false);
+            IOobject::writeEndDivider(os);
+        }
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Cannot open file " << dictFileName
+            << exit(FatalError, 1);
+    }
+
+    return 0;
+}
+
+
+// ************************************************************************* //