From c6520033c9c404d28000acd66d236f6a49ca9c83 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Mon, 15 Oct 2018 16:16:12 +0200
Subject: [PATCH] ENH: rationalize dictionary access methods

- use keyType::option enum to consolidate searching options.
  These enumeration names should be more intuitive to use
  and improve code readability.

    Eg,   lookupEntry(key, keyType::REGEX);
    vs    lookupEntry(key, false, true);

  or

    Eg,   lookupEntry(key, keyType::LITERAL_RECURSIVE);
    vs    lookupEntry(key, true, false);

- new findEntry(), findDict(), findScoped() methods with consolidated
  search options for shorter naming and access names more closely
  aligned with other components. Behave simliarly to the
  methods lookupEntryPtr(), subDictPtr(), lookupScopedEntryPtr(),
  respectively. Default search parameters consistent with lookupEntry().

    Eg, const entry* e = dict.findEntry(key);
    vs  const entry* e = dict.lookupEntryPtr(key, false, true);

- added '*' and '->' dereference operators to dictionary searchers.
---
 .../test/dictionary/Test-dictionary.C         |  22 +-
 .../Test-fvSolutionCombine.C                  |  12 +-
 .../cellSizeFunction/cellSizeFunction.C       |   8 +-
 .../conformalVoronoiMeshCalcDualMesh.C        |   2 +-
 .../conformationSurfaces.C                    |   2 +-
 .../generation/snappyHexMesh/snappyHexMesh.C  |   2 +-
 .../foamDictionary/foamDictionary.C           |  28 +-
 .../profilingSummary/profilingSummary.C       |  24 +-
 .../changeDictionary/changeDictionary.C       |  40 +-
 src/OpenFOAM/db/Time/Time.C                   |   4 +-
 src/OpenFOAM/db/Time/TimeIO.C                 |  10 +-
 src/OpenFOAM/db/dictionary/dictionary.C       | 140 ++---
 src/OpenFOAM/db/dictionary/dictionary.H       | 579 +++++++++++-------
 src/OpenFOAM/db/dictionary/dictionaryCompat.C |  31 +-
 src/OpenFOAM/db/dictionary/dictionaryIO.C     |  19 +-
 src/OpenFOAM/db/dictionary/dictionarySearch.C |  97 ++-
 .../db/dictionary/dictionaryTemplates.C       |  60 +-
 src/OpenFOAM/db/dictionary/entry/entryIO.C    |  12 +-
 .../functionEntries/removeEntry/removeEntry.C |   3 +-
 .../primitiveEntry/primitiveEntry.C           |   3 +-
 .../db/dynamicLibrary/codedBase/codedBase.C   |   6 +-
 .../dynamicCode/dynamicCodeContext.C          |  30 +-
 .../functionObjectList/functionObjectList.C   |   8 +-
 src/OpenFOAM/global/debug/debug.C             |  23 +-
 .../fileOperation/fileOperation.C             |   3 +-
 .../lduMatrix/lduMatrixPreconditioner.C       |  13 +-
 .../lduMatrix/lduMatrix/lduMatrixSmoother.C   |  12 +-
 src/OpenFOAM/matrices/solution/solution.C     |  19 +-
 .../Function1/Function1/Function1New.C        |   2 +-
 .../primitives/strings/keyType/keyType.H      |  22 +-
 .../primitives/strings/keyType/keyTypeI.H     |   4 +-
 .../primitives/strings/stringOps/stringOps.C  |  16 +-
 .../primitives/strings/wordRe/wordRe.H        |  16 +-
 .../motionSmoother/motionSmootherAlgoCheck.C  |  67 +-
 .../solutionControl/loopControl/loopControl.C |   7 +-
 .../codedFunctionObject/codedFunctionObject.C |  37 +-
 .../general/codedSource/CodedSourceIO.C       |  27 +-
 src/lumpedPointMotion/lumpedPointMovement.C   |   4 +-
 .../blockDescriptor/blockDescriptor.C         |   2 +-
 .../blockMesh/blockMesh/blockMeshTopology.C   |   2 +-
 .../blockMesh/blockMeshTools/blockMeshTools.C |  13 +-
 .../blockVertices/blockVertex/blockVertex.C   |   4 +-
 .../blockVertices/namedVertex/namedVertex.C   |   4 +-
 .../blockMesh/blocks/namedBlock/namedBlock.C  |   4 +-
 .../meshRefinementProblemCells.C              |   3 +-
 .../refinementSurfaces/refinementSurfaces.C   |   3 +-
 .../shellSurfaces/shellSurfaces.C             |  23 +-
 .../coordinate/systems/coordinateSystem.C     |   2 +-
 .../coordinate/systems/coordinateSystemNew.C  |   2 +-
 .../triSurfaceMesh/triSurfaceMesh.C           |   6 +-
 .../dynamicOversetFvMesh.C                    |   4 +-
 .../oversetPolyPatch/oversetFvPatchField.C    |   4 +-
 .../decompositionMethod/decompositionMethod.C |   2 +-
 .../multiLevelDecomp/multiLevelDecomp.C       |   8 +-
 .../decompose/metisDecomp/metisDecomp.C       |   2 +-
 .../regionModel/regionModel/regionModel.C     |  20 +-
 56 files changed, 769 insertions(+), 753 deletions(-)

diff --git a/applications/test/dictionary/Test-dictionary.C b/applications/test/dictionary/Test-dictionary.C
index 393aafe482..bddadce6fe 100644
--- a/applications/test/dictionary/Test-dictionary.C
+++ b/applications/test/dictionary/Test-dictionary.C
@@ -82,8 +82,8 @@ int main(int argc, char *argv[])
             Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc()
                 << endl;
 
-            dictionary dict3(dict2.subDictPtr("boundaryField"));
-            dictionary dict4(dict2.subDictPtr("NONEXISTENT"));
+            dictionary dict3(dict2.findDict("boundaryField"));
+            dictionary dict4(dict2.findDict("NONEXISTENT"));
 
             Info<< "dictionary construct from pointer" << nl
                 << "ok = " << dict3.name() << " " << dict3.toc() << nl
@@ -105,23 +105,17 @@ int main(int argc, char *argv[])
             Info<< "Pattern find \"abc\" in top directory : "
                 << dict.lookup("abc") << endl;
             Info<< "Pattern find \"abc\" in sub directory : "
-                << dict.subDict("someDict").lookup("abc")
-                    << endl;
+                << dict.subDict("someDict").lookup("abc") << nl;
             Info<< "Recursive pattern find \"def\" in sub directory : "
-                << dict.subDict("someDict").lookup("def", true)
-                    << endl;
+                << dict.subDict("someDict").lookup("def", true) << nl;
             Info<< "Recursive pattern find \"foo\" in sub directory : "
-                << dict.subDict("someDict").lookup("foo", true)
-                    << endl;
+                << dict.subDict("someDict").lookup("foo", true) << nl;
             Info<< "Recursive pattern find \"fooz\" in sub directory : "
-                << dict.subDict("someDict").lookup("fooz", true)
-                    << endl;
+                << dict.subDict("someDict").lookup("fooz", true) << nl;
             Info<< "Recursive pattern find \"bar\" in sub directory : "
-                << dict.subDict("someDict").lookup("bar", true)
-                    << endl;
+                << dict.subDict("someDict").lookup("bar", true) << nl;
             Info<< "Recursive pattern find \"xxx\" in sub directory : "
-                << dict.subDict("someDict").lookup("xxx", true)
-                    << endl;
+                << dict.subDict("someDict").lookup("xxx", true) << nl;
         }
     }
     else
diff --git a/applications/test/fvSolutionCombine/Test-fvSolutionCombine.C b/applications/test/fvSolutionCombine/Test-fvSolutionCombine.C
index c844c8286b..f3ed843680 100644
--- a/applications/test/fvSolutionCombine/Test-fvSolutionCombine.C
+++ b/applications/test/fvSolutionCombine/Test-fvSolutionCombine.C
@@ -52,20 +52,16 @@ bool checkDictionaryContent(const dictionary& dict1, const dictionary& dict2)
 
     forAllConstIter(dictionary, dict1, iter1)
     {
-        const entry* entryPtr = dict2.lookupEntryPtr
-        (
-            iter1().keyword(),
-            false,
-            false
-        );
+        const entry* eptr =
+            dict2.findEntry(iter1().keyword(), keyType::LITERAL);
 
-        if (!entryPtr)
+        if (!eptr)
         {
             return false;
         }
 
         const entry& entry1 = iter1();
-        const entry& entry2 = *entryPtr;
+        const entry& entry2 = *eptr;
 
         bool ok = false;
         if (entry1.isDict())
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
index 740b807f40..ca4e3280e3 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
@@ -63,9 +63,13 @@ Foam::cellSizeFunction::cellSizeFunction
     defaultCellSize_(defaultCellSize),
     regionIndices_(regionIndices),
     sideMode_(),
-    priority_(cellSizeFunctionDict.get<label>("priority", true))
+    priority_
+    (
+        cellSizeFunctionDict.get<label>("priority", keyType::REGEX_RECURSIVE)
+    )
 {
-    const word mode = cellSizeFunctionDict.get<word>("mode", true);
+    const word mode =
+        cellSizeFunctionDict.get<word>("mode", keyType::REGEX_RECURSIVE);
 
     if (surface_.hasVolumeType())
     {
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
index 00bad93cd8..d6f1256074 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
@@ -837,7 +837,7 @@ void Foam::conformalVoronoiMesh::checkCellSizing()
         = dict.subDict("meshQualityControls");
 
     const scalar maxNonOrtho =
-        meshQualityDict.get<scalar>("maxNonOrtho", true);
+        meshQualityDict.get<scalar>("maxNonOrtho", keyType::REGEX_RECURSIVE);
 
     label nWrongFaces = 0;
 
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C
index bc71e6d0f1..fba263b464 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformationSurfaces/conformationSurfaces.C
@@ -339,7 +339,7 @@ Foam::conformationSurfaces::conformationSurfaces
     {
         const word& geomName = allGeometry_.names()[geomI];
 
-        const entry* ePtr = surfacesDict.lookupEntryPtr(geomName, false, true);
+        const entry* ePtr = surfacesDict.findEntry(geomName, keyType::REGEX);
 
         if (ePtr)
         {
diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
index 5daa5766fe..5a7da19bb7 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
@@ -125,7 +125,7 @@ autoPtr<refinementSurfaces> createRefinementSurfaces
     {
         const word& geomName = allGeometry.names()[geomi];
 
-        const entry* ePtr = surfacesDict.lookupEntryPtr(geomName, false, true);
+        const entry* ePtr = surfacesDict.findEntry(geomName, keyType::REGEX);
 
         if (ePtr)
         {
diff --git a/applications/utilities/miscellaneous/foamDictionary/foamDictionary.C b/applications/utilities/miscellaneous/foamDictionary/foamDictionary.C
index dee2956e07..ce2e7ae101 100644
--- a/applications/utilities/miscellaneous/foamDictionary/foamDictionary.C
+++ b/applications/utilities/miscellaneous/foamDictionary/foamDictionary.C
@@ -170,9 +170,10 @@ class dictAndKeyword
     word key_;
 
 public:
+
     dictAndKeyword(const word& scopedName)
     {
-        string::size_type i = scopedName.rfind('/');
+        auto i = scopedName.rfind('/');
         if (i == string::npos)
         {
             i = scopedName.rfind('.');
@@ -212,7 +213,7 @@ const dictionary& lookupScopedDict
         return dict;
     }
 
-    const entry* eptr = dict.lookupScopedEntryPtr(subDictName, false, false);
+    const entry* eptr = dict.findScoped(subDictName, keyType::LITERAL);
 
     if (!eptr || !eptr->isDict())
     {
@@ -231,7 +232,7 @@ void removeDict(dictionary& dict, const dictionary& dictToRemove)
 {
     for (const entry& refEntry : dictToRemove)
     {
-        auto finder = dict.search(refEntry.keyword(), false, false);
+        auto finder = dict.search(refEntry.keyword(), keyType::LITERAL);
 
         bool purge = false;
 
@@ -357,8 +358,7 @@ int main(int argc, char *argv[])
     bool changed = false;
 
     // Read but preserve headers
-    dictionary dict;
-    dict.read(dictFile(), true);
+    dictionary dict(dictFile(), true);
 
     if (listIncludes)
     {
@@ -455,12 +455,7 @@ int main(int argc, char *argv[])
             changed = true;
 
             // Print the changed entry
-            const auto finder = dict.csearchScoped
-            (
-                scopedName,
-                false,
-                true  // Support wildcards
-            );
+            const auto finder = dict.csearchScoped(scopedName, keyType::REGEX);
 
             if (finder.found())
             {
@@ -489,8 +484,8 @@ int main(int argc, char *argv[])
                 const dictionary& d1(lookupScopedDict(dict, dAk.dict()));
                 const dictionary& d2(lookupScopedDict(diffDict, dAk.dict()));
 
-                const entry* e1Ptr = d1.lookupEntryPtr(dAk.key(), false, true);
-                const entry* e2Ptr = d2.lookupEntryPtr(dAk.key(), false, true);
+                const entry* e1Ptr = d1.findEntry(dAk.key(), keyType::REGEX);
+                const entry* e2Ptr = d2.findEntry(dAk.key(), keyType::REGEX);
 
                 if (e1Ptr && e2Ptr)
                 {
@@ -509,12 +504,7 @@ int main(int argc, char *argv[])
                 }
             }
 
-            const auto finder = dict.csearchScoped
-            (
-                scopedName,
-                false,
-                true  // Support wildcards
-            );
+            const auto finder = dict.csearchScoped(scopedName, keyType::REGEX);
 
             if (!finder.found())
             {
diff --git a/applications/utilities/postProcessing/miscellaneous/profilingSummary/profilingSummary.C b/applications/utilities/postProcessing/miscellaneous/profilingSummary/profilingSummary.C
index 920ba165a5..357c889d8a 100644
--- a/applications/utilities/postProcessing/miscellaneous/profilingSummary/profilingSummary.C
+++ b/applications/utilities/postProcessing/miscellaneous/profilingSummary/profilingSummary.C
@@ -183,7 +183,7 @@ int main(int argc, char *argv[])
 
                 // Assumed to be good if it has 'profiling' sub-dict
 
-                const dictionary* ptr = dict.subDictPtr(blockNameProfiling);
+                const dictionary* ptr = dict.findDict(blockNameProfiling);
                 if (ptr)
                 {
                     ++nDict;
@@ -295,13 +295,12 @@ int main(int argc, char *argv[])
 
                 for (const dictionary& procDict : profiles)
                 {
-                    const dictionary* inDictPtr =
-                        procDict.subDictPtr(level1Name);
+                    const dictionary* inDictPtr = procDict.findDict(level1Name);
 
                     if (inDictPtr && hasDictEntries)
                     {
-                        // descend to the next level as required
-                        inDictPtr = inDictPtr->subDictPtr(level2Name);
+                        // Descend to the next level as required
+                        inDictPtr = inDictPtr->findDict(level2Name);
                     }
 
                     if (!inDictPtr)
@@ -313,16 +312,13 @@ int main(int argc, char *argv[])
 
                     for (const word& tag : tags)
                     {
-                        const entry* eptr = inDictPtr->lookupEntryPtr
-                        (
-                            tag,
-                            false,
-                            false
-                        );
+                        scalar val;
 
-                        if (eptr)
+                        if
+                        (
+                            inDictPtr->readIfPresent(tag, val, keyType::LITERAL)
+                        )
                         {
-                            const scalar val = readScalar(eptr->stream());
                             stats(tag).append(val);
                         }
                     }
@@ -339,7 +335,7 @@ int main(int argc, char *argv[])
                 if (hasDictEntries)
                 {
                     outputDict.add(level2Name, level1Dict.subDict(level2Name));
-                    outDictPtr = outputDict.subDictPtr(level2Name);
+                    outDictPtr = outputDict.findDict(level2Name);
                 }
                 else
                 {
diff --git a/applications/utilities/preProcessing/changeDictionary/changeDictionary.C b/applications/utilities/preProcessing/changeDictionary/changeDictionary.C
index 8a39925f4f..4e86ce0af9 100644
--- a/applications/utilities/preProcessing/changeDictionary/changeDictionary.C
+++ b/applications/utilities/preProcessing/changeDictionary/changeDictionary.C
@@ -235,10 +235,9 @@ bool merge
     // Save current (non-wildcard) keys before adding items.
     wordHashSet thisKeysSet;
     {
-        List<keyType> keys = thisDict.keys(false);
-        forAll(keys, i)
+        for (const word& k : thisDict.keys(false))
         {
-            thisKeysSet.insert(keys[i]);
+            thisKeysSet.insert(k);
         }
     }
 
@@ -261,25 +260,20 @@ bool merge
         }
         else if (literalRE || !(key.isPattern() || shortcuts.found(key)))
         {
-            entry* entryPtr = thisDict.lookupEntryPtr
-            (
-                key,
-                false,              // recursive
-                false               // patternMatch
-            );
+            entry* eptr = thisDict.findEntry(key, keyType::LITERAL);
 
-            if (entryPtr)
+            if (eptr)
             {
                 // Mark thisDict entry as having been match for wildcard
                 // handling later on.
-                thisKeysSet.erase(entryPtr->keyword());
+                thisKeysSet.erase(eptr->keyword());
 
                 if
                 (
                     addEntry
                     (
                         thisDict,
-                       *entryPtr,
+                       *eptr,
                         mergeIter(),
                         literalRE,
                         shortcuts
@@ -310,7 +304,7 @@ bool merge
 
     // Pass 2. Wildcard or shortcut matches (if any) on any non-match keys.
 
-    if (!literalRE && thisKeysSet.size() > 0)
+    if (!literalRE && thisKeysSet.size())
     {
         // Pick up remaining dictionary entries
         wordList thisKeys(thisKeysSet.toc());
@@ -336,10 +330,10 @@ bool merge
                 );
 
                 // Remove all matches
-                forAll(matches, i)
+                for (const label matchi : matches)
                 {
-                    const word& thisKey = thisKeys[matches[i]];
-                    thisKeysSet.erase(thisKey);
+                    const word& k = thisKeys[matchi];
+                    thisKeysSet.erase(k);
                 }
                 changed = true;
             }
@@ -358,21 +352,18 @@ bool merge
                 );
 
                 // Add all matches
-                forAll(matches, i)
+                for (const label matchi : matches)
                 {
-                    const word& thisKey = thisKeys[matches[i]];
+                    const word& k = thisKeys[matchi];
 
-                    entry& thisEntry = const_cast<entry&>
-                    (
-                        thisDict.lookupEntry(thisKey, false, false)
-                    );
+                    entry* eptr = thisDict.findEntry(k, keyType::LITERAL);
 
                     if
                     (
                         addEntry
                         (
                             thisDict,
-                            thisEntry,
+                           *eptr,
                             mergeIter(),
                             literalRE,
                             HashTable<wordList>(0)    // no shortcuts
@@ -627,8 +618,7 @@ int main(int argc, char *argv[])
                         fieldDict.lookupEntry
                         (
                             doneKeys[i],
-                            false,
-                            true
+                            keyType::REGEX
                         ).clone()
                     );
                     fieldDict.remove(doneKeys[i]);
diff --git a/src/OpenFOAM/db/Time/Time.C b/src/OpenFOAM/db/Time/Time.C
index d85d0e3389..51b3819f88 100644
--- a/src/OpenFOAM/db/Time/Time.C
+++ b/src/OpenFOAM/db/Time/Time.C
@@ -342,11 +342,11 @@ void Foam::Time::setControls()
 
 void Foam::Time::setMonitoring(const bool forceProfiling)
 {
-    const dictionary* profilingDict = controlDict_.subDictPtr("profiling");
+    const dictionary* profilingDict = controlDict_.findDict("profiling");
     if (!profilingDict)
     {
         // ... or from etc/controlDict
-        profilingDict = debug::controlDict().subDictPtr("profiling");
+        profilingDict = debug::controlDict().findDict("profiling");
     }
 
     // initialize profiling on request
diff --git a/src/OpenFOAM/db/Time/TimeIO.C b/src/OpenFOAM/db/Time/TimeIO.C
index 9fb3cc0c70..ea45f1b2f3 100644
--- a/src/OpenFOAM/db/Time/TimeIO.C
+++ b/src/OpenFOAM/db/Time/TimeIO.C
@@ -99,7 +99,7 @@ void Foam::Time::readDict()
     // DebugSwitches
     if
     (
-        (localDict = controlDict_.subDictPtr("DebugSwitches")) != nullptr
+        (localDict = controlDict_.findDict("DebugSwitches")) != nullptr
      && localDict->size()
     )
     {
@@ -146,7 +146,7 @@ void Foam::Time::readDict()
     // InfoSwitches
     if
     (
-        (localDict = controlDict_.subDictPtr("InfoSwitches")) != nullptr
+        (localDict = controlDict_.findDict("InfoSwitches")) != nullptr
      && localDict->size()
     )
     {
@@ -192,7 +192,7 @@ void Foam::Time::readDict()
     // OptimisationSwitches
     if
     (
-        (localDict = controlDict_.subDictPtr("OptimisationSwitches")) != nullptr
+        (localDict = controlDict_.findDict("OptimisationSwitches")) != nullptr
      && localDict->size()
     )
     {
@@ -273,7 +273,7 @@ void Foam::Time::readDict()
     if
     (
 
-        (localDict = controlDict_.subDictPtr("DimensionedConstants")) != nullptr
+        (localDict = controlDict_.findDict("DimensionedConstants")) != nullptr
      && localDict->size()
     )
     {
@@ -310,7 +310,7 @@ void Foam::Time::readDict()
     // DimensionSets
     if
     (
-        (localDict = controlDict_.subDictPtr("DimensionSets")) != nullptr
+        (localDict = controlDict_.findDict("DimensionSets")) != nullptr
         && localDict->size()
     )
     {
diff --git a/src/OpenFOAM/db/dictionary/dictionary.C b/src/OpenFOAM/db/dictionary/dictionary.C
index 125c73e127..4cdc9a754c 100644
--- a/src/OpenFOAM/db/dictionary/dictionary.C
+++ b/src/OpenFOAM/db/dictionary/dictionary.C
@@ -134,13 +134,14 @@ void Foam::dictionary::checkITstream
 
 Foam::dictionary::dictionary()
 :
+    name_(),
     parent_(dictionary::null)
 {}
 
 
 Foam::dictionary::dictionary(const fileName& name)
 :
-    dictionaryName(name),
+    name_(name),
     parent_(dictionary::null)
 {}
 
@@ -151,8 +152,8 @@ Foam::dictionary::dictionary
     const dictionary& dict
 )
 :
-    dictionaryName(dict.name()),
     parent_type(dict, *this),
+    name_(dict.name()),
     parent_(parentDict)
 {
     forAllIter(parent_type, *this, iter)
@@ -173,8 +174,8 @@ Foam::dictionary::dictionary
     const dictionary& dict
 )
 :
-    dictionaryName(dict.name()),
     parent_type(dict, *this),
+    name_(dict.name()),
     parent_(dictionary::null)
 {
     forAllIter(parent_type, *this, iter)
@@ -190,16 +191,14 @@ Foam::dictionary::dictionary
 }
 
 
-Foam::dictionary::dictionary
-(
-    const dictionary* dictPtr
-)
+Foam::dictionary::dictionary(const dictionary* dict)
 :
+    name_(),
     parent_(dictionary::null)
 {
-    if (dictPtr)
+    if (dict)
     {
-        operator=(*dictPtr);
+        operator=(*dict);
     }
 }
 
@@ -210,6 +209,7 @@ Foam::dictionary::dictionary
     dictionary&& dict
 )
 :
+    name_(),
     parent_(parentDict)
 {
     transfer(dict);
@@ -222,6 +222,7 @@ Foam::dictionary::dictionary
     dictionary&& dict
 )
 :
+    name_(),
     parent_(dictionary::null)
 {
     transfer(dict);
@@ -310,44 +311,50 @@ Foam::tokenList Foam::dictionary::tokens() const
 bool Foam::dictionary::found
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    return csearch(keyword, recursive, patternMatch).found();
+    return csearch(keyword, matchOpt).found();
 }
 
 
-const Foam::entry* Foam::dictionary::lookupEntryPtr
+Foam::entry* Foam::dictionary::findEntry
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
-) const
-{
-    return csearch(keyword, recursive, patternMatch).ptr();
-}
-
-
-Foam::entry* Foam::dictionary::lookupEntryPtr
-(
-    const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 )
 {
-    return search(keyword, recursive, patternMatch).ptr();
+    return search(keyword, matchOpt).ptr();
+}
+
+
+const Foam::entry* Foam::dictionary::findEntry
+(
+    const word& keyword,
+    enum keyType::option matchOpt
+) const
+{
+    return csearch(keyword, matchOpt).ptr();
+}
+
+
+const Foam::entry* Foam::dictionary::findScoped
+(
+    const word& keyword,
+    enum keyType::option matchOpt
+) const
+{
+    return csearchScoped(keyword, matchOpt).ptr();
 }
 
 
 const Foam::entry& Foam::dictionary::lookupEntry
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    const const_searcher finder(csearch(keyword, recursive, patternMatch));
+    const const_searcher finder(csearch(keyword, matchOpt));
 
     if (!finder.found())
     {
@@ -364,22 +371,10 @@ const Foam::entry& Foam::dictionary::lookupEntry
 Foam::ITstream& Foam::dictionary::lookup
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    return lookupEntry(keyword, recursive, patternMatch).stream();
-}
-
-
-const Foam::entry* Foam::dictionary::lookupScopedEntryPtr
-(
-    const word& keyword,
-    bool recursive,
-    bool patternMatch
-) const
-{
-    return csearchScoped(keyword, recursive, patternMatch).ptr();
+    return lookupEntry(keyword, matchOpt).stream();
 }
 
 
@@ -394,7 +389,7 @@ bool Foam::dictionary::substituteKeyword(const word& keyword, bool mergeEntry)
     const word varName(keyword.substr(1), false);
 
     // Lookup the variable name in the given dictionary
-    const const_searcher finder(csearch(varName, true, true));
+    const const_searcher finder(csearch(varName, keyType::REGEX_RECURSIVE));
 
     // If defined insert its entries into this dictionary
     if (finder.found())
@@ -428,7 +423,7 @@ bool Foam::dictionary::substituteScopedKeyword
     const word varName(keyword.substr(1), false);
 
     // Lookup the variable name in the given dictionary
-    const const_searcher finder(csearchScoped(varName, true, true));
+    const auto finder(csearchScoped(varName, keyType::REGEX_RECURSIVE));
 
     // If defined insert its entries into this dictionary
     if (finder.found())
@@ -449,29 +444,35 @@ bool Foam::dictionary::substituteScopedKeyword
 
 bool Foam::dictionary::isDict(const word& keyword) const
 {
-    // Find non-recursive with patterns
-    return csearch(keyword, false, true).isDict();
+    // Allow patterns, non-recursive
+    return csearch(keyword, keyType::REGEX).isDict();
 }
 
 
-const Foam::dictionary* Foam::dictionary::subDictPtr(const word& keyword) const
+Foam::dictionary* Foam::dictionary::findDict
+(
+    const word& keyword,
+    enum keyType::option matchOpt
+)
 {
-    // Find non-recursive with patterns
-    return csearch(keyword, false, true).dictPtr();
+    return search(keyword, matchOpt).dictPtr();
 }
 
 
-Foam::dictionary* Foam::dictionary::subDictPtr(const word& keyword)
+const Foam::dictionary* Foam::dictionary::findDict
+(
+    const word& keyword,
+    enum keyType::option matchOpt
+) const
 {
-    // Find non-recursive with patterns
-    return search(keyword, false, true).dictPtr();
+    return csearch(keyword, matchOpt).dictPtr();
 }
 
 
 const Foam::dictionary& Foam::dictionary::subDict(const word& keyword) const
 {
-    // Find non-recursive with patterns
-    const const_searcher finder(csearch(keyword, false, true));
+    // Allow patterns, non-recursive
+    const const_searcher finder(csearch(keyword, keyType::REGEX));
 
     if (!finder.found())
     {
@@ -487,8 +488,8 @@ const Foam::dictionary& Foam::dictionary::subDict(const word& keyword) const
 
 Foam::dictionary& Foam::dictionary::subDict(const word& keyword)
 {
-    // Find non-recursive with patterns
-    searcher finder = search(keyword, false, true);
+    // Allow patterns, non-recursive
+    searcher finder(search(keyword, keyType::REGEX));
 
     if (!finder.found())
     {
@@ -508,8 +509,8 @@ Foam::dictionary Foam::dictionary::subOrEmptyDict
     const bool mandatory
 ) const
 {
-    // Find non-recursive with patterns
-    const const_searcher finder(csearch(keyword, false, true));
+    // Allow patterns, non-recursive
+    const const_searcher finder(csearch(keyword, keyType::REGEX));
 
     if (finder.isDict())
     {
@@ -543,7 +544,8 @@ const Foam::dictionary& Foam::dictionary::optionalSubDict
     const word& keyword
 ) const
 {
-    const const_searcher finder(csearch(keyword, false, true));
+    // Allow patterns, non-recursive
+    const const_searcher finder(csearch(keyword, keyType::REGEX));
 
     if (finder.isDict())
     {
@@ -565,15 +567,15 @@ const Foam::dictionary& Foam::dictionary::optionalSubDict
 
 Foam::wordList Foam::dictionary::toc() const
 {
-    wordList keys(size());
+    wordList list(size());
 
     label n = 0;
     forAllConstIters(*this, iter)
     {
-        keys[n++] = iter().keyword();
+        list[n++] = iter().keyword();
     }
 
-    return keys;
+    return list;
 }
 
 
@@ -585,19 +587,19 @@ Foam::wordList Foam::dictionary::sortedToc() const
 
 Foam::List<Foam::keyType> Foam::dictionary::keys(bool patterns) const
 {
-    List<keyType> keys(size());
+    List<keyType> list(size());
 
     label n = 0;
     forAllConstIters(*this, iter)
     {
         if (iter().keyword().isPattern() ? patterns : !patterns)
         {
-            keys[n++] = iter().keyword();
+            list[n++] = iter().keyword();
         }
     }
-    keys.setSize(n);
+    list.resize(n);
 
-    return keys;
+    return list;
 }
 
 
@@ -746,7 +748,7 @@ Foam::entry* Foam::dictionary::set(entry* entryPtr)
     }
 
     // Find non-recursive with patterns
-    searcher finder(search(entryPtr->keyword(), false, true));
+    searcher finder(search(entryPtr->keyword(), keyType::REGEX));
 
     // Clear dictionary so merge acts like overwrite
     if (finder.isDict())
diff --git a/src/OpenFOAM/db/dictionary/dictionary.H b/src/OpenFOAM/db/dictionary/dictionary.H
index 6364c722cb..b031835b00 100644
--- a/src/OpenFOAM/db/dictionary/dictionary.H
+++ b/src/OpenFOAM/db/dictionary/dictionary.H
@@ -112,70 +112,12 @@ class SHA1Digest;
 Istream& operator>>(Istream& is, dictionary& dict);
 Ostream& operator<<(Ostream& os, const dictionary& dict);
 
-/*---------------------------------------------------------------------------*\
-                        Class dictionaryName Declaration
-\*---------------------------------------------------------------------------*/
-
-//- Holds name for a dictionary
-class dictionaryName
-{
-    // Private data
-
-        fileName name_;
-
-
-public:
-
-    // Constructors
-
-        //- Construct null
-        dictionaryName()
-        {}
-
-        //- Construct as copy of the given fileName
-        dictionaryName(const fileName& name)
-        :
-            name_(name)
-        {}
-
-
-    // Member functions
-
-        //- Return the dictionary name
-        const fileName& name() const
-        {
-            return name_;
-        }
-
-        //- Return the dictionary name for modification (use with caution).
-        fileName& name()
-        {
-            return name_;
-        }
-
-        //- Return the local dictionary name (final part of scoped name)
-        word dictName() const
-        {
-            word scopedName(name_.name());
-
-            const auto i = scopedName.rfind('.');
-            if (i == std::string::npos)
-            {
-                return scopedName;
-            }
-
-            return scopedName.substr(i+1);
-        }
-};
-
-
 /*---------------------------------------------------------------------------*\
                          Class dictionary Declaration
 \*---------------------------------------------------------------------------*/
 
 class dictionary
 :
-    public dictionaryName,
     public IDLList<entry>
 {
 public:
@@ -250,7 +192,7 @@ public:
             {}
 
 
-            //- Entry was found.
+            //- True if entry was found
             inline bool found() const
             {
                 return eptr_;
@@ -298,6 +240,18 @@ public:
             {
                 return *reinterpret_cast<const Searcher<!Const>*>(this);
             }
+
+            //- A pointer to the entry (nullptr if not found)
+            pointer operator->() const
+            {
+                return eptr_;
+            }
+
+            //- A reference to the entry (Error if not found)
+            reference operator*() const
+            {
+                return *eptr_;
+            }
         };
 
 
@@ -326,6 +280,9 @@ private:
         //  Set/unset via an InfoSwitch
         static bool writeOptionalEntries;
 
+        //- The dictionary name
+        fileName name_;
+
         //- Parent dictionary
         const dictionary& parent_;
 
@@ -353,6 +310,21 @@ private:
 
     // Private Member Functions
 
+        //- Convert old-style (1806) boolean search specification to enum
+        //
+        //  \param recursive search parent dictionaries
+        //  \param pattern match using regular expressions as well
+        static inline enum keyType::option
+        matchOpt(bool recursive, bool pattern)
+        {
+            return
+                keyType::option
+                (
+                    (pattern ? keyType::REGEX : keyType::LITERAL)
+                  | (recursive ? keyType::RECURSIVE : 0)
+                );
+        }
+
         //- Search using a '.' for scoping.
         //  A leading dot means to use the parent dictionary.
         //  An intermediate dot separates a sub-dictionary or sub-entry.
@@ -363,13 +335,11 @@ private:
         //  The heuristic tries successively longer top-level entries
         //  until there is a suitable match.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the search mode
         const_searcher csearchDotScoped
         (
             const word& keyword,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option matchOpt
         ) const;
 
         //- Search using a '/' for scoping.
@@ -379,11 +349,11 @@ private:
         //  ambiguity between separator and content.
         //  No possibility or need for recursion.
         //
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the search mode. Recursive is ignored.
         const_searcher csearchSlashScoped
         (
             const word& keyword,
-            bool patternMatch
+            enum keyType::option matchOpt
         ) const;
 
 
@@ -411,16 +381,17 @@ public:
         explicit dictionary(const fileName& name);
 
         //- Construct given the entry name, parent dictionary and Istream,
-        //- reading entries until EOF
+        //- reading entries until EOF, optionally keeping the header
         dictionary
         (
             const fileName& name,
             const dictionary& parentDict,
-            Istream& is
+            Istream& is,
+            bool keepHeader = false
         );
 
         //- Construct top-level dictionary from Istream,
-        //- reading entries until EOF
+        //- reading entries until EOF. Discards the header.
         dictionary(Istream& is);
 
         //- Construct top-level dictionary from Istream,
@@ -435,7 +406,7 @@ public:
 
         //- Construct top-level dictionary as copy from pointer to dictionary.
         //  A null pointer is treated like an empty dictionary.
-        dictionary(const dictionary* dictPtr);
+        dictionary(const dictionary* dict);
 
         //- Move construct for given parent dictionary
         dictionary(const dictionary& parentDict, dictionary&& dict);
@@ -458,6 +429,32 @@ public:
 
     // Access
 
+        //- The dictionary name
+        const fileName& name() const
+        {
+            return name_;
+        }
+
+        //- The dictionary name for modification (use with caution).
+        fileName& name()
+        {
+            return name_;
+        }
+
+        //- The local dictionary name (final part of scoped name)
+        word dictName() const
+        {
+            word scopedName(name_.name());
+
+            const auto i = scopedName.rfind('.');
+            if (i == std::string::npos)
+            {
+                return scopedName;
+            }
+
+            return scopedName.substr(i+1);
+        }
+
         //- Return the parent dictionary
         const dictionary& parent() const
         {
@@ -482,131 +479,137 @@ public:
 
     // Search and lookup
 
-        //- Search dictionary for given keyword.
-        //  Default search: non-recursive with patterns.
+        //- Search for an entry (const access) with the given keyword.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the default search is non-recursive with patterns
+        //
+        //  \return True if entry was found
         bool found
         (
             const word& keyword,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option matchOpt = keyType::REGEX
         ) const;
 
-        //- Find and return an entry pointer if present, or return a nullptr.
+        //- Find for an entry (non-const access) with the given keyword.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
-        const entry* lookupEntryPtr
+        //  \param matchOpt the search mode
+        //
+        //  \return the entry pointer found or a nullptr.
+        entry* findEntry
         (
             const word& keyword,
-            bool recursive,
-            bool patternMatch
-        ) const;
-
-        //- Find and return an entry pointer for manipulation if present,
-        //- or return a nullptr.
-        //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
-        entry* lookupEntryPtr
-        (
-            const word& keyword,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option matchOpt = keyType::REGEX
         );
 
-        //- Find and return an entry if present, otherwise FatalIOError.
+        //- Find an entry (const access) with the given keyword.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the default search is non-recursive with patterns
+        //
+        //  \return the entry pointer found or a nullptr.
+        const entry* findEntry
+        (
+            const word& keyword,
+            enum keyType::option matchOpt = keyType::REGEX
+        ) const;
+
+        //- Search for a scoped entry (const access) with the given keyword.
+        //  Allows scoping using '.'.
+        //  Special handling for an absolute anchor (^) at start of the keyword
+        //  and for '..' to ascend into the parent dictionaries.
+        //
+        //  \param matchOpt the default search is non-recursive with patterns
+        //
+        //  \return the entry pointer found or a nullptr.
+        const entry* findScoped
+        (
+            const word& keyword,
+            enum keyType::option matchOpt = keyType::REGEX
+        ) const;
+
+        //- Find and return a sub-dictionary pointer if present
+        //  (and a sub-dictionary) otherwise return nullptr.
+        //
+        //  \param matchOpt the default search is non-recursive with patterns
+        dictionary* findDict
+        (
+            const word& keyword,
+            enum keyType::option matchOpt = keyType::REGEX
+        );
+
+        //- Search for an entry (const access) with the given keyword.
+        //- Find and return a sub-dictionary pointer if present
+        //  (and a sub-dictionary) otherwise return nullptr.
+        //
+        //  \param matchOpt the default search is non-recursive with patterns
+        const dictionary* findDict
+        (
+            const word& keyword,
+            enum keyType::option matchOpt = keyType::REGEX
+        ) const;
+
+        //
+        //  \param matchOpt the default search is non-recursive with patterns
+        //
+        //  \return return an entry if present, otherwise FatalIOError.
         const entry& lookupEntry
         (
             const word& keyword,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option matchOpt
         ) const;
 
         //- Find and return a T.
-        //- FatalIOError if not found, or if there are excess tokens.
-        //  Default search: non-recursive with patterns.
+        //- FatalIOError if not found, or if the number of tokens is incorrect.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the default search is non-recursive with patterns
         template<class T>
         T get
         (
             const word& keyword,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option matchOpt = keyType::REGEX
         ) const;
 
         //- Find and return an entry data stream.
-        //  Default search: non-recursive with patterns.
+        //- FatalIOError if not found, or if the number of tokens is incorrect.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the default search is non-recursive with patterns
         ITstream& lookup
         (
             const word& keyword,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option matchOpt = keyType::REGEX
         ) const;
 
-        //- Find and return a T.
-        //- FatalIOError if not found, or if there are excess tokens.
-        //  Default search: non-recursive with patterns.
+        //- Find and return a T, or return the given default value.
+        //- FatalIOError if it is found and the number of tokens is incorrect.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
-        //
-        //  \deprecated - same as the get() method
-        template<class T>
-        T lookupType
-        (
-            const word& keyword,
-            bool recursive = false,
-            bool patternMatch = true
-        ) const;
-
-        //- Find and return a T, or return the given default value
-        //- FatalIOError if it is found and there are excess tokens.
-        //  Default search: non-recursive with patterns.
-        //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the default search is non-recursive with patterns
         template<class T>
         T lookupOrDefault
         (
             const word& keyword,
             const T& deflt,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option matchOpt = keyType::REGEX
         ) const;
 
         //- Find and return a T, or return the given default value
         //- and add it to dictionary.
-        //- FatalIOError if it is found and there are excess tokens.
-        //  Default search: non-recursive with patterns.
+        //- FatalIOError if it is found and the number of tokens is incorrect.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param matchOpt the default search is non-recursive with patterns
         template<class T>
         T lookupOrAddDefault
         (
             const word& keyword,
             const T& deflt,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option matchOpt = keyType::REGEX
         );
 
         //- Find entry and assign to T val.
-        //- FatalIOError if it is found and there are excess tokens.
-        //  Default search: non-recursive with patterns.
+        //- FatalIOError if it is found and the number of tokens is incorrect,
+        //- or it is mandatory and not found.
         //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param val the value to read into
+        //  \param matchOpt the default search is non-recursive with patterns
+        //  \param mandatory the keyword is mandatory
         //
         //  \return true if the entry was found.
         template<class T>
@@ -614,18 +617,16 @@ public:
         (
             const word& keyword,
             T& val,
-            bool recursive = false,
-            bool patternMatch = true,
+            enum keyType::option matchOpt = keyType::REGEX,
             bool mandatory = true
         ) const;
 
         //- Find an entry if present, and assign to T val.
-        //- FatalIOError if it is found and there are excess tokens.
+        //- FatalIOError if it is found and the number of tokens is incorrect.
         //  Default search: non-recursive with patterns.
         //
-        //  \param val the value to read
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
+        //  \param val the value to read into
+        //  \param matchOpt the default search is non-recursive with patterns
         //
         //  \return true if the entry was found.
         template<class T>
@@ -633,41 +634,14 @@ public:
         (
             const word& keyword,
             T& val,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option matchOpt = keyType::REGEX
         ) const;
 
-        //- Find and return an entry pointer if present, or return a nullptr.
-        //  Allows scoping using '.'.
-        //  Special handling for an absolute anchor (^) at start of the keyword
-        //  and for '..' to ascend into the parent dictionaries.
-        //
-        //  \param recursive search parent dictionaries
-        //  \param patternMatch use regular expressions
-        const entry* lookupScopedEntryPtr
-        (
-            const word& keyword,
-            bool recursive,
-            bool patternMatch
-        ) const;
-
-        //- Check if entry exists and is a sub-dictionary.
+        //- Check if entry is found and and is a sub-dictionary.
         //
         //  Search type: non-recursive with patterns.
         bool isDict(const word& keyword) const;
 
-        //- Find and return a sub-dictionary pointer if present
-        //  (and a sub-dictionary) otherwise return nullptr.
-        //
-        //  Search type: non-recursive with patterns.
-        const dictionary* subDictPtr(const word& keyword) const;
-
-        //- Find and return a sub-dictionary pointer if present
-        //  (and a sub-dictionary) otherwise return nullptr.
-        //
-        //  Search type: non-recursive with patterns.
-        dictionary* subDictPtr(const word& keyword);
-
         //- Find and return a sub-dictionary.
         //  Fatal if the entry does not exist or is not a sub-dictionary.
         //
@@ -856,8 +830,7 @@ public:
         const_searcher csearch
         (
             const word& keyword,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
         //- Search dictionary for given keyword
@@ -868,8 +841,7 @@ public:
         const_searcher search
         (
             const word& keyword,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
         //- Search dictionary for given keyword
@@ -880,8 +852,7 @@ public:
         searcher search
         (
             const word& keyword,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         );
 
         //- Search using scoping.
@@ -910,8 +881,7 @@ public:
         const_searcher csearchScoped
         (
             const word& keyword,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option
         ) const;
 
         //- Search using dot or slash scoping.
@@ -921,8 +891,7 @@ public:
         const_searcher searchScoped
         (
             const word& keyword,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option
         ) const;
 
         //- Search using dot or slash scoping.
@@ -932,25 +901,24 @@ public:
         searcher searchScoped
         (
             const word& keyword,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option
         );
 
         //- Locate a sub-dictionary using slash-scoping
         //  \return nullptr if the dictionary path does not exist
-        const dictionary* cfindScopedDictPtr(const fileName& dictPath) const;
+        const dictionary* cfindScopedDict(const fileName& dictPath) const;
 
         //- Locate a sub-dictionary using slash-scoping
         //  \return nullptr if the dictionary path does not exist
-        const dictionary* findScopedDictPtr(const fileName& dictPath) const;
+        const dictionary* findScopedDict(const fileName& dictPath) const;
 
         //- Locate a sub-dictionary using slash-scoping
         //  \return nullptr if the dictionary path does not exist
-        dictionary* findScopedDictPtr(const fileName& dictPath);
+        dictionary* findScopedDict(const fileName& dictPath);
 
         //- Locate existing or create sub-dictionary using slash-scoping
         //  \return nullptr if the dictionary path could not be created
-        dictionary* makeScopedDictPtr(const fileName& dictPath);
+        dictionary* makeScopedDict(const fileName& dictPath);
 
 
     // Compatibility helpers
@@ -969,8 +937,7 @@ public:
         (
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
         //- Search dictionary for given keyword and any compatibility names
@@ -984,8 +951,7 @@ public:
         (
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
         //- Find and return an entry pointer if present, or return a nullptr,
@@ -995,12 +961,11 @@ public:
         //      OpenFOAM version for which they were used.
         //  \param recursive search parent dictionaries
         //  \param patternMatch use regular expressions
-        const entry* lookupEntryPtrCompat
+        const entry* findCompat
         (
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option
         ) const;
 
         //- Find and return an entry if present, otherwise FatalIOError,
@@ -1014,8 +979,7 @@ public:
         (
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
-            bool recursive,
-            bool patternMatch
+            enum keyType::option
         ) const;
 
         //- Find and return a T
@@ -1032,8 +996,7 @@ public:
         (
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
         //- Find and return an entry data stream,
@@ -1048,8 +1011,7 @@ public:
         (
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
         //- Find and return a T, or return the given default value
@@ -1066,8 +1028,7 @@ public:
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
             const T& deflt,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
         //- Find entry and assign to T val
@@ -1088,8 +1049,7 @@ public:
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
             T& val,
-            bool recursive = false,
-            bool patternMatch = true,
+            enum keyType::option = keyType::REGEX,
             bool mandatory = true
         ) const;
 
@@ -1111,22 +1071,12 @@ public:
             const word& keyword,
             std::initializer_list<std::pair<const char*,int>> compat,
             T& val,
-            bool recursive = false,
-            bool patternMatch = true
+            enum keyType::option = keyType::REGEX
         ) const;
 
 
     // Member Operators
 
-        //- Find and return an entry data stream (identical to #lookup method).
-        //  Search: non-recursive with patterns.
-        //
-        //  \deprecated use lookup() method instead (deprecated JUL-2018)
-        ITstream& operator[](const word& keyword) const
-        {
-            return lookup(keyword);
-        }
-
         //- Copy assignment
         void operator=(const dictionary& rhs);
 
@@ -1152,19 +1102,196 @@ public:
         friend Ostream& operator<<(Ostream& os, const dictionary& dict);
 
 
-    // Shortcuts - may be more useable in templated code
+    // Housekeeping
+
+        //- Find and return an entry data stream (identical to #lookup method).
+        //
+        //  \deprecated use lookup() method instead (JUL-2018)
+        ITstream& operator[](const word& keyword) const
+        {
+            return lookup(keyword);
+        }
+
+        //- Find and return a T.
+        //  \deprecated - same as the get() method (OCT-2018)
+        template<class T>
+        T lookupType
+        (
+            const word& keyword,
+            bool recursive = false,
+            bool patternMatch = true
+        ) const
+        {
+            return get<T>(keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Search dictionary for given keyword.
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        bool found
+        (
+            const word& keyword,
+            bool recursive,
+            bool patternMatch = true
+        ) const
+        {
+            return found(keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find and return an entry pointer for manipulation if present,
+        //- or return a nullptr.
+        //
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        entry* lookupEntryPtr
+        (
+            const word& keyword,
+            bool recursive,
+            bool patternMatch
+        )
+        {
+            return findEntry(keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find and return an entry pointer if present, or return a nullptr.
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        const entry* lookupEntryPtr
+        (
+            const word& keyword,
+            bool recursive,
+            bool patternMatch
+        ) const
+        {
+            return findEntry(keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find and return an entry pointer if present, or return a nullptr.
+        //  Allows scoping using '.'.
+        //  Special handling for an absolute anchor (^) at start of the keyword
+        //  and for '..' to ascend into the parent dictionaries.
+        //
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        const entry* lookupScopedEntryPtr
+        (
+            const word& keyword,
+            bool recursive,
+            bool patternMatch
+        ) const
+        {
+            return findScoped(keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find and return a sub-dictionary pointer if present
+        //  (and a sub-dictionary) otherwise return nullptr.
+        //
+        //  Search type: non-recursive with patterns.
+        const dictionary* subDictPtr(const word& keyword) const
+        {
+            return findDict(keyword, keyType::REGEX);
+        }
+
+        //- Find and return a sub-dictionary pointer if present
+        //  (and a sub-dictionary) otherwise return nullptr.
+        //
+        //  Search type: non-recursive with patterns.
+        dictionary* subDictPtr(const word& keyword)
+        {
+            return findDict(keyword, keyType::REGEX);
+        }
+
+        //- Find and return an entry if present, otherwise FatalIOError.
+        //
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        const entry& lookupEntry
+        (
+            const word& keyword,
+            bool recursive,
+            bool patternMatch
+        ) const
+        {
+            return lookupEntry(keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find and return an entry data stream.
+        //  Default search: non-recursive with patterns.
+        //
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        ITstream& lookup
+        (
+            const word& keyword,
+            bool recursive,
+            bool patternMatch = true
+        ) const
+        {
+            return lookup(keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find and return a T, or return the given default value
+        //- FatalIOError if it is found and there are excess tokens.
+        //
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        template<class T>
+        T lookupOrDefault
+        (
+            const word& keyword,
+            const T& deflt,
+            bool recursive,
+            bool patternMatch = true
+        ) const
+        {
+            return
+                lookupOrDefault
+                (keyword, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find and return a T, or return the given default value
+        //- and add it to dictionary.
+        //- FatalIOError if it is found and there are excess tokens.
+        //
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        template<class T>
+        T lookupOrAddDefault
+        (
+            const word& keyword,
+            const T& deflt,
+            bool recursive,
+            bool patternMatch = true
+        )
+        {
+            return
+                lookupOrAddDefault
+                (keyword, deflt, matchOpt(recursive, patternMatch));
+        }
+
+        //- Find an entry if present, and assign to T val.
+        //- FatalIOError if it is found and there are excess tokens.
+        //
+        //  \deprecated - use keyType::option version instead (OCT-2018)
+        template<class T>
+        bool readIfPresent
+        (
+            const word& keyword,
+            T& val,
+            bool recursive,
+            bool patternMatch = true
+        ) const
+        {
+            return
+                readIfPresent
+                (keyword, val, matchOpt(recursive, patternMatch));
+        }
+
+
+    // Shortcuts - when a templated classes also inherits from a dictionary
 
         #undef defineDictionaryGetter
-        #define defineDictionaryGetter(Func,Type)                             \
+        #define defineDictionaryGetter(Func, Type)                            \
             /** Same as get\<Type\> */                                        \
             Type Func                                                         \
             (                                                                 \
                 const word& keyword,                                          \
-                bool recursive = false,                                       \
-                bool patternMatch = true                                      \
+                enum keyType::option matchOpt = keyType::REGEX                \
             ) const                                                           \
             {                                                                 \
-                return get<Type>(keyword, recursive, patternMatch);           \
+                return get<Type>(keyword, matchOpt);                          \
             }
 
         defineDictionaryGetter(getBool, bool);
diff --git a/src/OpenFOAM/db/dictionary/dictionaryCompat.C b/src/OpenFOAM/db/dictionary/dictionaryCompat.C
index 49fb277fb5..c16f7de0d8 100644
--- a/src/OpenFOAM/db/dictionary/dictionaryCompat.C
+++ b/src/OpenFOAM/db/dictionary/dictionaryCompat.C
@@ -49,11 +49,10 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchCompat
 (
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    const_searcher finder(csearch(keyword, recursive, patternMatch));
+    const_searcher finder(csearch(keyword, matchOpt));
 
     if (finder.found())
     {
@@ -62,7 +61,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchCompat
 
     for (const std::pair<const char*,int>& iter : compat)
     {
-        finder = csearch(word::validate(iter.first), recursive, patternMatch);
+        finder = csearch(word::validate(iter.first), matchOpt);
 
         if (finder.found())
         {
@@ -99,23 +98,21 @@ bool Foam::dictionary::foundCompat
 (
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    return csearchCompat(keyword, compat, recursive, patternMatch).found();
+    return csearchCompat(keyword, compat, matchOpt).found();
 }
 
 
-const Foam::entry* Foam::dictionary::lookupEntryPtrCompat
+const Foam::entry* Foam::dictionary::findCompat
 (
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    return csearchCompat(keyword, compat, recursive, patternMatch).ptr();
+    return csearchCompat(keyword, compat, matchOpt).ptr();
 }
 
 
@@ -123,12 +120,10 @@ const Foam::entry& Foam::dictionary::lookupEntryCompat
 (
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    const const_searcher
-        finder(csearchCompat(keyword, compat, recursive, patternMatch));
+    const const_searcher finder(csearchCompat(keyword, compat, matchOpt));
 
     if (!finder.found())
     {
@@ -146,12 +141,10 @@ Foam::ITstream& Foam::dictionary::lookupCompat
 (
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    return
-        lookupEntryCompat(keyword, compat, recursive, patternMatch).stream();
+    return lookupEntryCompat(keyword, compat, matchOpt).stream();
 }
 
 
diff --git a/src/OpenFOAM/db/dictionary/dictionaryIO.C b/src/OpenFOAM/db/dictionary/dictionaryIO.C
index 7a51ae2d67..de4ff879aa 100644
--- a/src/OpenFOAM/db/dictionary/dictionaryIO.C
+++ b/src/OpenFOAM/db/dictionary/dictionaryIO.C
@@ -33,31 +33,26 @@ Foam::dictionary::dictionary
 (
     const fileName& name,
     const dictionary& parentDict,
-    Istream& is
+    Istream& is,
+    bool keepHeader
 )
 :
-    dictionaryName(parentDict.name() + '.' + name),
+    name_(parentDict.name() + '.' + name),
     parent_(parentDict)
 {
-    read(is);
+    read(is, keepHeader);
 }
 
 
 Foam::dictionary::dictionary(Istream& is)
 :
-    dictionaryName(is.name()),
-    parent_(dictionary::null)
-{
-    // Reset input mode as this is a "top-level" dictionary
-    entry::resetInputMode();
-
-    read(is);
-}
+    dictionary(is, false)
+{}
 
 
 Foam::dictionary::dictionary(Istream& is, bool keepHeader)
 :
-    dictionaryName(is.name()),
+    name_(is.name()),
     parent_(dictionary::null)
 {
     // Reset input mode as this is a "top-level" dictionary
diff --git a/src/OpenFOAM/db/dictionary/dictionarySearch.C b/src/OpenFOAM/db/dictionary/dictionarySearch.C
index 4c8ec03c07..902d10f07d 100644
--- a/src/OpenFOAM/db/dictionary/dictionarySearch.C
+++ b/src/OpenFOAM/db/dictionary/dictionarySearch.C
@@ -69,8 +69,7 @@ namespace
 Foam::dictionary::const_searcher Foam::dictionary::csearchDotScoped
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
     auto scopePos = keyword.find('.');
@@ -78,9 +77,12 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchDotScoped
     if (scopePos == string::npos)
     {
         // Normal, non-scoped search
-        return csearch(keyword, recursive, patternMatch);
+        return csearch(keyword, matchOpt);
     }
 
+    // It is '.' scoped - force non-recusive searching
+    matchOpt = keyType::option(matchOpt & ~(keyType::RECURSIVE));
+
     if (scopePos == 0)
     {
         // Starting with a '.' -> go up for every further '.' found
@@ -113,8 +115,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchDotScoped
         return dictPtr->csearchDotScoped
         (
             keyword.substr(scopePos),
-            false,
-            patternMatch
+            matchOpt
         );
     }
 
@@ -122,8 +123,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchDotScoped
     const_searcher finder = csearchDotScoped
     (
         keyword.substr(0, scopePos),
-        false,
-        patternMatch
+        matchOpt
     );
 
     // Fall back to finding key with '.' so e.g. if keyword is
@@ -137,7 +137,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchDotScoped
             scopePos = keyword.find('.', scopePos+1);
 
             // Local entry:
-            finder = csearch(keyword.substr(0, scopePos), false, patternMatch);
+            finder = csearch(keyword.substr(0, scopePos), matchOpt);
 
             if (scopePos == string::npos)
             {
@@ -152,8 +152,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchDotScoped
         return finder.dict().csearchDotScoped
         (
             keyword.substr(scopePos),
-            false,
-            patternMatch
+            matchOpt
         );
     }
 
@@ -164,9 +163,13 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchDotScoped
 Foam::dictionary::const_searcher Foam::dictionary::csearchSlashScoped
 (
     const word& keyword,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
+
+    // With '/' scoping - recursive is never allowed
+    matchOpt = keyType::option(matchOpt & ~(keyType::RECURSIVE));
+
     const dictionary* dictPtr = this;
 
     const auto slash = keyword.find('/');
@@ -175,7 +178,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchSlashScoped
     {
         // No slashes:
         // Can use normal (non-scoped) search at the current dictionary level
-        return csearch(keyword, false, patternMatch);
+        return csearch(keyword, matchOpt);
     }
     else if (slash == 0)
     {
@@ -220,7 +223,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchSlashScoped
             // Find entry
             const word key = word::validate(cmpt);
 
-            auto finder = dictPtr->csearch(key, false, patternMatch);
+            auto finder = dictPtr->csearch(key, matchOpt);
 
             if (finder.found())
             {
@@ -259,8 +262,7 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchSlashScoped
 Foam::dictionary::const_searcher Foam::dictionary::csearch
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
     const_searcher finder(this);
@@ -273,27 +275,22 @@ Foam::dictionary::const_searcher Foam::dictionary::csearch
         return finder;
     }
 
-    if (patternMatch && patterns_.size())
+    if ((matchOpt & keyType::REGEX) && patterns_.size())
     {
         pattern_const_iterator wcLink = patterns_.begin();
         regexp_const_iterator  reLink = regexps_.begin();
 
         // Find in patterns using regular expressions only
-        if (findInPatterns(patternMatch, keyword, wcLink, reLink))
+        if (findInPatterns(true, keyword, wcLink, reLink))
         {
             finder.set(*wcLink);
             return finder;
         }
     }
 
-    if (recursive && &parent_ != &dictionary::null)
+    if ((matchOpt & keyType::RECURSIVE) && &parent_ != &dictionary::null)
     {
-        return parent_.csearch
-        (
-            keyword,
-            recursive,
-            patternMatch
-        );
+        return parent_.csearch(keyword, matchOpt);
     }
 
     return finder;
@@ -303,22 +300,20 @@ Foam::dictionary::const_searcher Foam::dictionary::csearch
 Foam::dictionary::const_searcher Foam::dictionary::search
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    return csearch(keyword, recursive, patternMatch);
+    return csearch(keyword, matchOpt);
 }
 
 
 Foam::dictionary::searcher Foam::dictionary::search
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 )
 {
-    const_searcher finder = csearch(keyword, recursive, patternMatch);
+    const_searcher finder = csearch(keyword, matchOpt);
 
     return static_cast<const searcher&>(finder);
 }
@@ -327,17 +322,19 @@ Foam::dictionary::searcher Foam::dictionary::search
 Foam::dictionary::const_searcher Foam::dictionary::csearchScoped
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
     if (keyword.find('/') != string::npos)
     {
-        return csearchSlashScoped(keyword, patternMatch);
+        return csearchSlashScoped(keyword, matchOpt);
     }
 
     if (keyword[0] == ':' || keyword[0] == '^')
     {
+        // It is ':' scoped - force non-recusive searching
+        matchOpt = keyType::option(matchOpt & ~(keyType::RECURSIVE));
+
         // Ascend to top-level
         const dictionary* dictPtr = this;
         while (&dictPtr->parent_ != &dictionary::null)
@@ -345,43 +342,36 @@ Foam::dictionary::const_searcher Foam::dictionary::csearchScoped
             dictPtr = &dictPtr->parent_;
         }
 
-        return dictPtr->csearchDotScoped
-        (
-            keyword.substr(1),
-            false,
-            patternMatch
-        );
+        return dictPtr->csearchDotScoped(keyword.substr(1), matchOpt);
     }
 
-    return csearchDotScoped(keyword, recursive, patternMatch);
+    return csearchDotScoped(keyword, matchOpt);
 }
 
 
 Foam::dictionary::const_searcher Foam::dictionary::searchScoped
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    return csearchScoped(keyword, recursive, patternMatch);
+    return csearchScoped(keyword, matchOpt);
 }
 
 
 Foam::dictionary::searcher Foam::dictionary::searchScoped
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 )
 {
-    const_searcher finder = csearchScoped(keyword, recursive, patternMatch);
+    const_searcher finder = csearchScoped(keyword, matchOpt);
 
     return static_cast<const searcher&>(finder);
 }
 
 
-const Foam::dictionary* Foam::dictionary::cfindScopedDictPtr
+const Foam::dictionary* Foam::dictionary::cfindScopedDict
 (
     const fileName& dictPath
 ) const
@@ -466,26 +456,26 @@ const Foam::dictionary* Foam::dictionary::cfindScopedDictPtr
 }
 
 
-const Foam::dictionary* Foam::dictionary::findScopedDictPtr
+const Foam::dictionary* Foam::dictionary::findScopedDict
 (
     const fileName& dictPath
 ) const
 {
-    return cfindScopedDictPtr(dictPath);
+    return cfindScopedDict(dictPath);
 }
 
 
-Foam::dictionary* Foam::dictionary::findScopedDictPtr
+Foam::dictionary* Foam::dictionary::findScopedDict
 (
     const fileName& dictPath
 )
 {
-    const dictionary* ptr = cfindScopedDictPtr(dictPath);
+    const dictionary* ptr = cfindScopedDict(dictPath);
     return const_cast<dictionary*>(ptr);
 }
 
 
-Foam::dictionary* Foam::dictionary::makeScopedDictPtr(const fileName& dictPath)
+Foam::dictionary* Foam::dictionary::makeScopedDict(const fileName& dictPath)
 {
     // Or warning
     if (dictPath.empty())
@@ -536,7 +526,8 @@ Foam::dictionary* Foam::dictionary::makeScopedDictPtr(const fileName& dictPath)
         else
         {
             // Non-recursive, no patternMatch
-            // -> can do direct lookup, without csearch(cmptName, false, false);
+            // -> can do direct lookup,
+            // without csearch(cmptName, keyType::LITERAL);
             const word cmptName(cmpt.str(), false);
 
             auto iter = dictPtr->hashedEntries_.find(cmptName);
diff --git a/src/OpenFOAM/db/dictionary/dictionaryTemplates.C b/src/OpenFOAM/db/dictionary/dictionaryTemplates.C
index fab47e6488..a8656dcb08 100644
--- a/src/OpenFOAM/db/dictionary/dictionaryTemplates.C
+++ b/src/OpenFOAM/db/dictionary/dictionaryTemplates.C
@@ -53,12 +53,11 @@ template<class T>
 T Foam::dictionary::get
 (
     const word& keyword,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
     T val;
-    readEntry<T>(keyword, val, recursive, patternMatch);
+    readEntry<T>(keyword, val, matchOpt);
     return val;
 }
 
@@ -68,12 +67,11 @@ T Foam::dictionary::getCompat
 (
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
     T val;
-    readCompat<T>(keyword, compat, val, recursive, patternMatch);
+    readCompat<T>(keyword, compat, val, matchOpt);
     return val;
 }
 
@@ -84,13 +82,11 @@ bool Foam::dictionary::readCompat
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
     T& val,
-    bool recursive,
-    bool patternMatch,
+    enum keyType::option matchOpt,
     bool mandatory
 ) const
 {
-    const const_searcher
-        finder(csearchCompat(keyword, compat, recursive, patternMatch));
+    const const_searcher finder(csearchCompat(keyword, compat, matchOpt));
 
     if (finder.found())
     {
@@ -113,29 +109,15 @@ bool Foam::dictionary::readCompat
 }
 
 
-// older name
-template<class T>
-T Foam::dictionary::lookupType
-(
-    const word& keyword,
-    bool recursive,
-    bool patternMatch
-) const
-{
-    return get<T>(keyword, recursive, patternMatch);
-}
-
-
 template<class T>
 T Foam::dictionary::lookupOrDefault
 (
     const word& keyword,
     const T& deflt,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    const const_searcher finder(csearch(keyword, recursive, patternMatch));
+    const const_searcher finder(csearch(keyword, matchOpt));
 
     if (finder.found())
     {
@@ -165,11 +147,10 @@ T Foam::dictionary::lookupOrAddDefault
 (
     const word& keyword,
     const T& deflt,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 )
 {
-    const const_searcher finder(csearch(keyword, recursive, patternMatch));
+    const const_searcher finder(csearch(keyword, matchOpt));
 
     if (finder.found())
     {
@@ -200,12 +181,11 @@ bool Foam::dictionary::readEntry
 (
     const word& keyword,
     T& val,
-    bool recursive,
-    bool patternMatch,
+    enum keyType::option matchOpt,
     bool mandatory
 ) const
 {
-    const const_searcher finder(csearch(keyword, recursive, patternMatch));
+    const const_searcher finder(csearch(keyword, matchOpt));
 
     if (finder.found())
     {
@@ -233,12 +213,11 @@ bool Foam::dictionary::readIfPresent
 (
     const word& keyword,
     T& val,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
     // Read is non-mandatory
-    return readEntry<T>(keyword, val, recursive, patternMatch, false);
+    return readEntry<T>(keyword, val, matchOpt, false);
 }
 
 
@@ -248,12 +227,10 @@ T Foam::dictionary::lookupOrDefaultCompat
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
     const T& deflt,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
-    const const_searcher
-        finder(csearchCompat(keyword, compat, recursive, patternMatch));
+    const const_searcher finder(csearchCompat(keyword, compat, matchOpt));
 
     if (finder.found())
     {
@@ -284,12 +261,11 @@ bool Foam::dictionary::readIfPresentCompat
     const word& keyword,
     std::initializer_list<std::pair<const char*,int>> compat,
     T& val,
-    bool recursive,
-    bool patternMatch
+    enum keyType::option matchOpt
 ) const
 {
     // Read is non-mandatory
-    return readCompat<T>(keyword, compat, val, recursive, patternMatch, false);
+    return readCompat<T>(keyword, compat, val, matchOpt, false);
 }
 
 
diff --git a/src/OpenFOAM/db/dictionary/entry/entryIO.C b/src/OpenFOAM/db/dictionary/entry/entryIO.C
index 0e50a68e9b..cd7a335c0b 100644
--- a/src/OpenFOAM/db/dictionary/entry/entryIO.C
+++ b/src/OpenFOAM/db/dictionary/entry/entryIO.C
@@ -241,7 +241,8 @@ bool Foam::entry::New
             const word varName = keyword.substr(1);
 
             // Lookup the variable name in the given dictionary
-            const auto finder = parentDict.csearchScoped(varName, true, true);
+            const auto finder =
+                parentDict.csearchScoped(varName, keyType::REGEX_RECURSIVE);
 
             if (finder.found())
             {
@@ -301,8 +302,8 @@ bool Foam::entry::New
         auto finder =
         (
             scoped
-          ? parentDict.searchScoped(keyword, false, false)
-          : parentDict.search(keyword, false, false)
+          ? parentDict.searchScoped(keyword, keyType::LITERAL)
+          : parentDict.search(keyword, keyType::LITERAL)
         );
 
         // How to manage duplicate entries
@@ -387,10 +388,7 @@ bool Foam::entry::New
             // Get or create the dictionary-path.
             // fileName::path == dictionary-path
             dictionary* subDictPtr =
-                parentDict.makeScopedDictPtr
-                (
-                    fileName::path(fullPath)
-                );
+                parentDict.makeScopedDict(fileName::path(fullPath));
 
             if (subDictPtr)
             {
diff --git a/src/OpenFOAM/db/dictionary/functionEntries/removeEntry/removeEntry.C b/src/OpenFOAM/db/dictionary/functionEntries/removeEntry/removeEntry.C
index 25e452fce3..2a216f5c5f 100644
--- a/src/OpenFOAM/db/dictionary/functionEntries/removeEntry/removeEntry.C
+++ b/src/OpenFOAM/db/dictionary/functionEntries/removeEntry/removeEntry.C
@@ -61,8 +61,7 @@ bool Foam::functionEntries::removeEntry::execute
         if (key.isLiteral() && key.find('/') != string::npos)
         {
             // Remove scoped keyword, or keyword in the local scope
-            dictionary::searcher finder =
-                parentDict.searchScoped(key, false, false);
+            auto finder(parentDict.searchScoped(key, keyType::LITERAL));
 
             if (finder.found())
             {
diff --git a/src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.C b/src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.C
index 0998353e9f..3c8715a2c0 100644
--- a/src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.C
+++ b/src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.C
@@ -78,7 +78,8 @@ bool Foam::primitiveEntry::expandVariable
     // The $internalField would be matched by the ".*" !!!
 
     // Recursive, non-patterns
-    const entry* eptr = dict.lookupScopedEntryPtr(varName, true, false);
+    const entry* eptr = dict.findScoped(varName, keyType::LITERAL_RECURSIVE);
+
     if (!eptr)
     {
         // Not found - revert to environment variable
diff --git a/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.C b/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.C
index f7dabea32c..0cbb02b7a2 100644
--- a/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.C
+++ b/src/OpenFOAM/db/dynamicLibrary/codedBase/codedBase.C
@@ -55,14 +55,14 @@ static inline void writeEntryIfPresent
 )
 {
     // non-recursive like dictionary::found, but no pattern-match either
-    const entry* ptr = dict.lookupEntryPtr(key, false, false);
+    const entry* eptr = dict.findEntry(key, keyType::LITERAL);
 
-    if (ptr)
+    if (eptr)
     {
         os.writeKeyword(key)
             << token::HASH << token::BEGIN_BLOCK;
 
-        os.writeQuoted(string(ptr->stream()), false)
+        os.writeQuoted(string(eptr->stream()), false)
             << token::HASH << token::END_BLOCK
             << token::END_STATEMENT << nl;
     }
diff --git a/src/OpenFOAM/db/dynamicLibrary/dynamicCode/dynamicCodeContext.C b/src/OpenFOAM/db/dynamicLibrary/dynamicCode/dynamicCodeContext.C
index 6f41078867..a626aa7874 100644
--- a/src/OpenFOAM/db/dynamicLibrary/dynamicCode/dynamicCodeContext.C
+++ b/src/OpenFOAM/db/dynamicLibrary/dynamicCode/dynamicCodeContext.C
@@ -44,50 +44,40 @@ Foam::dynamicCodeContext::dynamicCodeContext(const dictionary& dict)
     // - necessary for compilation options, convenient for includes
     // and body.
 
-    const entry* codePtr = dict.lookupEntryPtr
-    (
-        "code",
-        false,
-        false
-    );
+    const entry* codePtr = dict.findEntry("code", keyType::LITERAL);
+
     if (codePtr)
     {
         code_ = stringOps::trim(codePtr->stream());
         stringOps::inplaceExpand(code_, dict);
     }
 
-    const entry* includePtr = dict.lookupEntryPtr
-    (
-        "codeInclude",
-        false,
-        false
-    );
+    const entry* includePtr = dict.findEntry("codeInclude", keyType::LITERAL);
+
     if (includePtr)
     {
         include_ = stringOps::trim(includePtr->stream());
         stringOps::inplaceExpand(include_, dict);
     }
 
-    const entry* optionsPtr = dict.lookupEntryPtr
-    (
-        "codeOptions",
-        false,
-        false
-    );
+    const entry* optionsPtr = dict.findEntry("codeOptions", keyType::LITERAL);
+
     if (optionsPtr)
     {
         options_ = stringOps::trim(optionsPtr->stream());
         stringOps::inplaceExpand(options_, dict);
     }
 
-    const entry* libsPtr = dict.lookupEntryPtr("codeLibs", false, false);
+    const entry* libsPtr = dict.findEntry("codeLibs", keyType::LITERAL);
+
     if (libsPtr)
     {
         libs_ = stringOps::trim(libsPtr->stream());
         stringOps::inplaceExpand(libs_, dict);
     }
 
-    const entry* localPtr = dict.lookupEntryPtr("localCode", false, false);
+    const entry* localPtr = dict.findEntry("localCode", keyType::LITERAL);
+
     if (localPtr)
     {
         localCode_ = stringOps::trim(localPtr->stream());
diff --git a/src/OpenFOAM/db/functionObjects/functionObjectList/functionObjectList.C b/src/OpenFOAM/db/functionObjects/functionObjectList/functionObjectList.C
index db9902b94f..2fd7f11563 100644
--- a/src/OpenFOAM/db/functionObjects/functionObjectList/functionObjectList.C
+++ b/src/OpenFOAM/db/functionObjects/functionObjectList/functionObjectList.C
@@ -706,12 +706,8 @@ bool Foam::functionObjectList::read()
     }
 
     // Update existing and add new functionObjects
-    const entry* entryPtr = parentDict_.lookupEntryPtr
-    (
-        "functions",
-        false,
-        false
-    );
+    const entry* entryPtr =
+        parentDict_.findEntry("functions", keyType::LITERAL);
 
     if (entryPtr)
     {
diff --git a/src/OpenFOAM/global/debug/debug.C b/src/OpenFOAM/global/debug/debug.C
index 2b7206cc4f..d9102084f1 100644
--- a/src/OpenFOAM/global/debug/debug.C
+++ b/src/OpenFOAM/global/debug/debug.C
@@ -135,12 +135,9 @@ Foam::dictionary& Foam::debug::switchSet
 {
     if (!subDictPtr)
     {
-        entry* ePtr = controlDict().lookupEntryPtr
-        (
-            subDictName, false, false
-        );
+        entry* eptr = controlDict().findEntry(subDictName, keyType::LITERAL);
 
-        if (!ePtr || !ePtr->isDict())
+        if (!eptr || !eptr->isDict())
         {
             cerr<< "debug::switchSet(const char*, dictionary*&):\n"
                 << "    Cannot find " <<  subDictName << " in dictionary "
@@ -150,7 +147,7 @@ Foam::dictionary& Foam::debug::switchSet
             ::exit(1);
         }
 
-        subDictPtr = &ePtr->dict();
+        subDictPtr = &(eptr->dict());
     }
 
     return *subDictPtr;
@@ -179,7 +176,7 @@ int Foam::debug::debugSwitch(const char* name, const int defaultValue)
 {
     return debugSwitches().lookupOrAddDefault
     (
-        name, defaultValue, false, false
+        name, defaultValue, keyType::LITERAL
     );
 }
 
@@ -188,7 +185,7 @@ int Foam::debug::infoSwitch(const char* name, const int defaultValue)
 {
     return infoSwitches().lookupOrAddDefault
     (
-        name, defaultValue, false, false
+        name, defaultValue, keyType::LITERAL
     );
 }
 
@@ -197,7 +194,7 @@ int Foam::debug::optimisationSwitch(const char* name, const int defaultValue)
 {
     return optimisationSwitches().lookupOrAddDefault
     (
-        name, defaultValue, false, false
+        name, defaultValue, keyType::LITERAL
     );
 }
 
@@ -210,7 +207,7 @@ float Foam::debug::floatOptimisationSwitch
 {
     return optimisationSwitches().lookupOrAddDefault
     (
-        name, defaultValue, false, false
+        name, defaultValue, keyType::LITERAL
     );
 }
 
@@ -412,17 +409,17 @@ void listSwitches
 
         wordHashSet controlDictDebug
         (
-            controlDict.subDict("DebugSwitches").sortedToc()
+            controlDict.subDict("DebugSwitches").toc()
         );
 
         wordHashSet controlDictInfo
         (
-            controlDict.subDict("InfoSwitches").sortedToc()
+            controlDict.subDict("InfoSwitches").toc()
         );
 
         wordHashSet controlDictOpt
         (
-            controlDict.subDict("OptimisationSwitches").sortedToc()
+            controlDict.subDict("OptimisationSwitches").toc()
         );
 
 
diff --git a/src/OpenFOAM/global/fileOperations/fileOperation/fileOperation.C b/src/OpenFOAM/global/fileOperations/fileOperation/fileOperation.C
index 03cf4bc80c..a06170d709 100644
--- a/src/OpenFOAM/global/fileOperations/fileOperation/fileOperation.C
+++ b/src/OpenFOAM/global/fileOperations/fileOperation/fileOperation.C
@@ -50,8 +50,7 @@ namespace Foam
             "fileHandler",
             //Foam::fileOperations::uncollatedFileOperation::typeName,
             "uncollated",
-            false,
-            false
+            keyType::LITERAL
         )
     );
 }
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixPreconditioner.C b/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixPreconditioner.C
index 892f6569d1..88a1f86380 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixPreconditioner.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixPreconditioner.C
@@ -43,8 +43,10 @@ Foam::word Foam::lduMatrix::preconditioner::getName
 {
     word name;
 
-    // handle primitive or dictionary entry
-    const entry& e = solverControls.lookupEntry("preconditioner", false, false);
+    // Handle primitive or dictionary entry
+    const entry& e =
+        solverControls.lookupEntry("preconditioner", keyType::LITERAL);
+
     if (e.isDict())
     {
         e.dict().readEntry("preconditioner", name);
@@ -67,8 +69,11 @@ Foam::lduMatrix::preconditioner::New
 {
     word name;
 
-    // handle primitive or dictionary entry
-    const entry& e = solverControls.lookupEntry("preconditioner", false, false);
+    // Handle primitive or dictionary entry
+
+    const entry& e =
+        solverControls.lookupEntry("preconditioner", keyType::LITERAL);
+
     if (e.isDict())
     {
         e.dict().readEntry("preconditioner", name);
diff --git a/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSmoother.C b/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSmoother.C
index 3399023218..0e1bbaa015 100644
--- a/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSmoother.C
+++ b/src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSmoother.C
@@ -43,8 +43,10 @@ Foam::lduMatrix::smoother::getName
 {
     word name;
 
-    // handle primitive or dictionary entry
-    const entry& e = solverControls.lookupEntry("smoother", false, false);
+    // Handle primitive or dictionary entry
+    const entry& e =
+        solverControls.lookupEntry("smoother", keyType::LITERAL);
+
     if (e.isDict())
     {
         e.dict().readEntry("smoother", name);
@@ -70,8 +72,10 @@ Foam::autoPtr<Foam::lduMatrix::smoother> Foam::lduMatrix::smoother::New
 {
     word name;
 
-    // handle primitive or dictionary entry
-    const entry& e = solverControls.lookupEntry("smoother", false, false);
+    // Handle primitive or dictionary entry
+    const entry& e =
+        solverControls.lookupEntry("smoother", keyType::LITERAL);
+
     if (e.isDict())
     {
         e.dict().readEntry("smoother", name);
diff --git a/src/OpenFOAM/matrices/solution/solution.C b/src/OpenFOAM/matrices/solution/solution.C
index b08dde5b91..b2a3a07800 100644
--- a/src/OpenFOAM/matrices/solution/solution.C
+++ b/src/OpenFOAM/matrices/solution/solution.C
@@ -35,9 +35,9 @@ namespace Foam
 
 // List of sub-dictionaries to rewrite
 static const Foam::List<Foam::word> subDictNames
-{
+({
     "preconditioner", "smoother"
-};
+});
 
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
@@ -184,14 +184,13 @@ Foam::label Foam::solution::upgradeSolverDict
             // 1) primitiveEntry w/o settings,
             // 2) or a dictionaryEntry.
             // transform primitiveEntry with settings -> dictionaryEntry
-            forAll(subDictNames, dictI)
+            for (const word& dictName : subDictNames)
             {
-                const word& dictName = subDictNames[dictI];
-                entry* ePtr = subdict.lookupEntryPtr(dictName,false,false);
+                entry* eptr = subdict.findEntry(dictName, keyType::LITERAL);
 
-                if (ePtr && !ePtr->isDict())
+                if (eptr && !eptr->isDict())
                 {
-                    Istream& is = ePtr->stream();
+                    Istream& is = eptr->stream();
                     is >> name;
 
                     if (!is.eof())
@@ -234,10 +233,8 @@ bool Foam::solution::cache(const word& name) const
 
         return cache_.found(name);
     }
-    else
-    {
-        return false;
-    }
+
+    return false;
 }
 
 
diff --git a/src/OpenFOAM/primitives/functions/Function1/Function1/Function1New.C b/src/OpenFOAM/primitives/functions/Function1/Function1/Function1New.C
index fe97b5acc2..9063d21f83 100644
--- a/src/OpenFOAM/primitives/functions/Function1/Function1/Function1New.C
+++ b/src/OpenFOAM/primitives/functions/Function1/Function1/Function1New.C
@@ -57,7 +57,7 @@ Foam::autoPtr<Foam::Function1<Type>> Foam::Function1<Type>::New
     }
     else
     {
-        Istream& is(dict.lookup(entryName, false));
+        Istream& is = dict.lookup(entryName); // non-recursive, allow patterns
 
         token firstToken(is);
         word Function1Type;
diff --git a/src/OpenFOAM/primitives/strings/keyType/keyType.H b/src/OpenFOAM/primitives/strings/keyType/keyType.H
index 608468105f..cf9db5128f 100644
--- a/src/OpenFOAM/primitives/strings/keyType/keyType.H
+++ b/src/OpenFOAM/primitives/strings/keyType/keyType.H
@@ -82,6 +82,20 @@ public:
         static const keyType null;
 
 
+    // Public data types
+
+        //- Enumeration for search/match modes as bitmask
+        //  eg, (keyType::REGEX | keyType::RECURSIVE)
+        enum option
+        {
+            LITERAL = 0,        //!< String literal
+            REGEX   = 1,        //!< Regular expression
+            RECURSIVE = 0x10,   //!< Recursive search (eg, in dictionary)
+            LITERAL_RECURSIVE = (LITERAL | RECURSIVE),
+            REGEX_RECURSIVE   = (REGEX | RECURSIVE)
+        };
+
+
     // Constructors
 
         //- Construct null
@@ -100,19 +114,19 @@ public:
         inline keyType(const char* s);
 
         //- Copy construct from std::string with specified treatment
-        inline keyType(const std::string& s, const bool isPattern);
+        inline keyType(const std::string& s, bool isPattern);
 
         //- Move construct, retaining type (literal or regex)
         inline keyType(keyType&& s);
 
-        //- Move construct from word. Not treated as a regular expression
+        //- Move construct from word, treat as literal.
         inline keyType(word&& s);
 
-        //- Move construct from string. Treat as regular expression.
+        //- Move construct from string, treat as regular expression.
         inline keyType(string&& s);
 
         //- Move construct from std::string with specified treatment
-        inline keyType(std::string&& s, const bool isPattern);
+        inline keyType(std::string&& s, bool isPattern);
 
         //- Construct from Istream
         //  Treat as regular expression if surrounded by quotation marks.
diff --git a/src/OpenFOAM/primitives/strings/keyType/keyTypeI.H b/src/OpenFOAM/primitives/strings/keyType/keyTypeI.H
index bf84de6a23..3b4b0f3289 100644
--- a/src/OpenFOAM/primitives/strings/keyType/keyTypeI.H
+++ b/src/OpenFOAM/primitives/strings/keyType/keyTypeI.H
@@ -77,7 +77,7 @@ inline Foam::keyType::keyType(const char* s)
 {}
 
 
-inline Foam::keyType::keyType(const std::string& s, const bool isPattern)
+inline Foam::keyType::keyType(const std::string& s, bool isPattern)
 :
     word(s, false),
     isPattern_(isPattern)
@@ -107,7 +107,7 @@ inline Foam::keyType::keyType(string&& s)
 {}
 
 
-inline Foam::keyType::keyType(std::string&& s, const bool isPattern)
+inline Foam::keyType::keyType(std::string&& s, bool isPattern)
 :
     word(std::move(s), false),
     isPattern_(isPattern)
diff --git a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C b/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
index 484ef5f9f5..325e64051d 100644
--- a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
+++ b/src/OpenFOAM/primitives/strings/stringOps/stringOps.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) 2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -437,7 +437,7 @@ Foam::string Foam::stringOps::getVariable
 {
     string value;
 
-    const entry* eptr = dict.lookupScopedEntryPtr(name, true, false);
+    const entry* eptr = dict.findScoped(name, keyType::LITERAL_RECURSIVE);
 
     if (eptr)
     {
@@ -720,20 +720,16 @@ void Foam::stringOps::inplaceExpand
                         varBeg + 1 + delim,
                         varEnd - varBeg - 2*delim
                     ),
-                    false
+                    false   // Already validated
                 );
 
 
                 // Lookup in the dictionary without wildcards.
                 // See note in primitiveEntry
-                const entry* eptr = dict.lookupScopedEntryPtr
-                (
-                    varName,
-                    true,
-                    false
-                );
+                const entry* eptr =
+                    dict.findScoped(varName, keyType::LITERAL_RECURSIVE);
 
-                // if defined - copy its entries
+                // Copy its entries if defined
                 if (eptr)
                 {
                     OStringStream buf;
diff --git a/src/OpenFOAM/primitives/strings/wordRe/wordRe.H b/src/OpenFOAM/primitives/strings/wordRe/wordRe.H
index 9976ecb6dc..5b83bda346 100644
--- a/src/OpenFOAM/primitives/strings/wordRe/wordRe.H
+++ b/src/OpenFOAM/primitives/strings/wordRe/wordRe.H
@@ -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) 2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2017-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -96,14 +96,14 @@ public:
         //  Note that 'REGEX' is implicit if 'ICASE' is specified alone.
         enum compOption
         {
-            LITERAL = 0, //!< Treat as a string literal
-            DETECT  = 1, //!< Detect if the string contains meta-characters
-            UNKNOWN = 1, //!< Unknown content.
-            REGEX   = 2, //!< Treat as regular expression
-            ICASE   = 4, //!< Ignore case in regular expression
-            NOCASE  = 4, //!< \deprecated Alias for ICASE (deprecated APR-2018)
+            LITERAL = 0, //!< String literal
+            REGEX   = 1, //!< Regular expression
+            ICASE   = 2, //!< Ignore case in regular expression
+            NOCASE  = 2, //!< \deprecated Alias for ICASE (deprecated APR-2018)
+            DETECT  = 4, //!< Detect if the string contains meta-characters
+            UNKNOWN = 4, //!< Unknown content.
+            REGEX_ICASE  = (REGEX|ICASE),   //!< Combined REGEX and ICASE
             DETECT_ICASE = (DETECT|ICASE),  //!< Combined DETECT and ICASE
-            REGEX_ICASE  = (REGEX|ICASE)    //!< Combined REGEX and ICASE
         };
 
 
diff --git a/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C b/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C
index 8a5aadee53..361fbe216e 100644
--- a/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C
+++ b/src/dynamicMesh/motionSmoother/motionSmootherAlgoCheck.C
@@ -62,53 +62,59 @@ bool Foam::motionSmootherAlgo::checkMesh
 {
     const scalar maxNonOrtho
     (
-        dict.get<scalar>("maxNonOrtho", true)
+        dict.get<scalar>("maxNonOrtho", keyType::REGEX_RECURSIVE)
     );
     const scalar minVol
     (
-        dict.get<scalar>("minVol", true)
+        dict.get<scalar>("minVol", keyType::REGEX_RECURSIVE)
     );
     const scalar minTetQuality
     (
-        dict.get<scalar>("minTetQuality", true)
+        dict.get<scalar>("minTetQuality", keyType::REGEX_RECURSIVE)
     );
     const scalar maxConcave
     (
-        dict.get<scalar>("maxConcave", true)
+        dict.get<scalar>("maxConcave", keyType::REGEX_RECURSIVE)
     );
     const scalar minArea
     (
-        dict.get<scalar>("minArea", true)
+        dict.get<scalar>("minArea", keyType::REGEX_RECURSIVE)
     );
     const scalar maxIntSkew
     (
-        dict.get<scalar>("maxInternalSkewness", true)
+        dict.get<scalar>("maxInternalSkewness", keyType::REGEX_RECURSIVE)
     );
     const scalar maxBounSkew
     (
-        dict.get<scalar>("maxBoundarySkewness", true)
+        dict.get<scalar>("maxBoundarySkewness", keyType::REGEX_RECURSIVE)
     );
     const scalar minWeight
     (
-        dict.get<scalar>("minFaceWeight", true)
+        dict.get<scalar>("minFaceWeight", keyType::REGEX_RECURSIVE)
     );
     const scalar minVolRatio
     (
-        dict.get<scalar>("minVolRatio", true)
+        dict.get<scalar>("minVolRatio", keyType::REGEX_RECURSIVE)
     );
     const scalar minTwist
     (
-        dict.get<scalar>("minTwist", true)
+        dict.get<scalar>("minTwist", keyType::REGEX_RECURSIVE)
     );
     const scalar minTriangleTwist
     (
-        dict.get<scalar>("minTriangleTwist", true)
+        dict.get<scalar>("minTriangleTwist", keyType::REGEX_RECURSIVE)
+    );
+
+    const scalar minFaceFlatness
+    (
+        dict.lookupOrDefault<scalar>
+        (
+            "minFaceFlatness", -1, keyType::REGEX_RECURSIVE
+        )
     );
-    scalar minFaceFlatness = -1.0;
-    dict.readIfPresent("minFaceFlatness", minFaceFlatness, true);
     const scalar minDet
     (
-        dict.get<scalar>("minDeterminant", true)
+        dict.get<scalar>("minDeterminant", keyType::REGEX_RECURSIVE)
     );
     label nWrongFaces = 0;
 
@@ -467,53 +473,58 @@ bool Foam::motionSmootherAlgo::checkMesh
 {
     const scalar maxNonOrtho
     (
-        dict.get<scalar>("maxNonOrtho", true)
+        dict.get<scalar>("maxNonOrtho", keyType::REGEX_RECURSIVE)
     );
     const scalar minVol
     (
-        dict.get<scalar>("minVol", true)
+        dict.get<scalar>("minVol", keyType::REGEX_RECURSIVE)
     );
     const scalar minTetQuality
     (
-        dict.get<scalar>("minTetQuality", true)
+        dict.get<scalar>("minTetQuality", keyType::REGEX_RECURSIVE)
     );
     const scalar maxConcave
     (
-        dict.get<scalar>("maxConcave", true)
+        dict.get<scalar>("maxConcave", keyType::REGEX_RECURSIVE)
     );
     const scalar minArea
     (
-        dict.get<scalar>("minArea", true)
+        dict.get<scalar>("minArea", keyType::REGEX_RECURSIVE)
     );
     const scalar maxIntSkew
     (
-        dict.get<scalar>("maxInternalSkewness", true)
+        dict.get<scalar>("maxInternalSkewness", keyType::REGEX_RECURSIVE)
     );
     const scalar maxBounSkew
     (
-        dict.get<scalar>("maxBoundarySkewness", true)
+        dict.get<scalar>("maxBoundarySkewness", keyType::REGEX_RECURSIVE)
     );
     const scalar minWeight
     (
-        dict.get<scalar>("minFaceWeight", true)
+        dict.get<scalar>("minFaceWeight", keyType::REGEX_RECURSIVE)
     );
     const scalar minVolRatio
     (
-        dict.get<scalar>("minVolRatio", true)
+        dict.get<scalar>("minVolRatio", keyType::REGEX_RECURSIVE)
     );
     const scalar minTwist
     (
-        dict.get<scalar>("minTwist", true)
+        dict.get<scalar>("minTwist", keyType::REGEX_RECURSIVE)
     );
     const scalar minTriangleTwist
     (
-        dict.get<scalar>("minTriangleTwist", true)
+        dict.get<scalar>("minTriangleTwist", keyType::REGEX_RECURSIVE)
+    );
+    const scalar minFaceFlatness
+    (
+        dict.lookupOrDefault<scalar>
+        (
+            "minFaceFlatness", -1, keyType::REGEX_RECURSIVE
+        )
     );
-    scalar minFaceFlatness = -1.0;
-    dict.readIfPresent("minFaceFlatness", minFaceFlatness, true);
     const scalar minDet
     (
-        dict.get<scalar>("minDeterminant", true)
+        dict.get<scalar>("minDeterminant", keyType::REGEX_RECURSIVE)
     );
     label nWrongFaces = 0;
 
diff --git a/src/finiteVolume/cfdTools/general/solutionControl/loopControl/loopControl.C b/src/finiteVolume/cfdTools/general/solutionControl/loopControl/loopControl.C
index c403486a2c..e8b4d8551a 100644
--- a/src/finiteVolume/cfdTools/general/solutionControl/loopControl/loopControl.C
+++ b/src/finiteVolume/cfdTools/general/solutionControl/loopControl/loopControl.C
@@ -170,7 +170,7 @@ Foam::loopControl::loopControl
     loopControl(runTime, 0, dictName)
 {
     // The loop sub-dictionary
-    const dictionary* dictptr = algorithmDict.subDictPtr(dictName);
+    const dictionary* dictptr = algorithmDict.findDict(dictName);
 
     if (dictptr)
     {
@@ -192,13 +192,12 @@ Foam::loopControl::loopControl
     fvSolution fvsol(time_);
 
     // Eg, PIMPLE or SIMPLE from <system/fvSolution>
-    const dictionary* dictptr =
-        fvsol.solutionDict().subDictPtr(algorithmName);
+    const dictionary* dictptr = fvsol.solutionDict().findDict(algorithmName);
 
     if (dictptr)
     {
         // The loop sub-dictionary
-        dictptr = dictptr->subDictPtr(dictName);
+        dictptr = dictptr->findDict(dictName);
 
         if (dictptr)
         {
diff --git a/src/functionObjects/utilities/codedFunctionObject/codedFunctionObject.C b/src/functionObjects/utilities/codedFunctionObject/codedFunctionObject.C
index 62d65ffaf3..6b4136d384 100644
--- a/src/functionObjects/utilities/codedFunctionObject/codedFunctionObject.C
+++ b/src/functionObjects/utilities/codedFunctionObject/codedFunctionObject.C
@@ -193,12 +193,7 @@ bool Foam::functionObjects::codedFunctionObject::read(const dictionary& dict)
 
     dict.readCompat<word>("name", {{"redirectType", 1706}}, name_);
 
-    const entry* dataPtr = dict.lookupEntryPtr
-    (
-        "codeData",
-        false,
-        false
-    );
+    const entry* dataPtr = dict.findEntry("codeData", keyType::LITERAL);
     if (dataPtr)
     {
         codeData_ = stringOps::trim(dataPtr->stream());
@@ -211,12 +206,7 @@ bool Foam::functionObjects::codedFunctionObject::read(const dictionary& dict)
         );
     }
 
-    const entry* readPtr = dict.lookupEntryPtr
-    (
-        "codeRead",
-        false,
-        false
-    );
+    const entry* readPtr = dict.findEntry("codeRead", keyType::LITERAL);
     if (readPtr)
     {
         codeRead_ = stringOps::trim(readPtr->stream());
@@ -229,12 +219,7 @@ bool Foam::functionObjects::codedFunctionObject::read(const dictionary& dict)
         );
     }
 
-    const entry* execPtr = dict.lookupEntryPtr
-    (
-        "codeExecute",
-        false,
-        false
-    );
+    const entry* execPtr = dict.findEntry("codeExecute", keyType::LITERAL);
     if (execPtr)
     {
         codeExecute_ = stringOps::trim(execPtr->stream());
@@ -247,12 +232,7 @@ bool Foam::functionObjects::codedFunctionObject::read(const dictionary& dict)
         );
     }
 
-    const entry* writePtr = dict.lookupEntryPtr
-    (
-        "codeWrite",
-        false,
-        false
-    );
+    const entry* writePtr = dict.findEntry("codeWrite", keyType::LITERAL);
     if (writePtr)
     {
         codeWrite_ = stringOps::trim(writePtr->stream());
@@ -265,12 +245,7 @@ bool Foam::functionObjects::codedFunctionObject::read(const dictionary& dict)
         );
     }
 
-    const entry* endPtr = dict.lookupEntryPtr
-    (
-        "codeEnd",
-        false,
-        false
-    );
+    const entry* endPtr = dict.findEntry("codeEnd", keyType::LITERAL);
     if (endPtr)
     {
         codeEnd_ = stringOps::trim(endPtr->stream());
@@ -283,7 +258,7 @@ bool Foam::functionObjects::codedFunctionObject::read(const dictionary& dict)
         );
     }
 
-    if(!dataPtr && !readPtr && !execPtr && !writePtr && !endPtr)
+    if (!dataPtr && !readPtr && !execPtr && !writePtr && !endPtr)
     {
         IOWarningInFunction
         (
diff --git a/src/fvOptions/sources/general/codedSource/CodedSourceIO.C b/src/fvOptions/sources/general/codedSource/CodedSourceIO.C
index bf27297e0e..8cbeeecda2 100644
--- a/src/fvOptions/sources/general/codedSource/CodedSourceIO.C
+++ b/src/fvOptions/sources/general/codedSource/CodedSourceIO.C
@@ -40,12 +40,9 @@ bool Foam::fv::CodedSource<Type>::read(const dictionary& dict)
 
         // Code snippets
         {
-            const entry& e = coeffs_.lookupEntry
-            (
-                "codeCorrect",
-                false,
-                false
-            );
+            const entry& e =
+                coeffs_.lookupEntry("codeCorrect", keyType::LITERAL);
+
             codeCorrect_ = stringOps::trim(e.stream());
             stringOps::inplaceExpand(codeCorrect_, coeffs_);
             dynamicCodeContext::addLineDirective
@@ -57,12 +54,9 @@ bool Foam::fv::CodedSource<Type>::read(const dictionary& dict)
         }
 
         {
-            const entry& e = coeffs_.lookupEntry
-            (
-                "codeAddSup",
-                false,
-                false
-            );
+            const entry& e =
+                coeffs_.lookupEntry("codeAddSup", keyType::LITERAL);
+
             codeAddSup_ = stringOps::trim(e.stream());
             stringOps::inplaceExpand(codeAddSup_, coeffs_);
             dynamicCodeContext::addLineDirective
@@ -74,12 +68,9 @@ bool Foam::fv::CodedSource<Type>::read(const dictionary& dict)
         }
 
         {
-            const entry& e = coeffs_.lookupEntry
-            (
-                "codeSetValue",
-                false,
-                false
-            );
+            const entry& e =
+                coeffs_.lookupEntry("codeSetValue", keyType::LITERAL);
+
             codeSetValue_ = stringOps::trim(e.stream());
             stringOps::inplaceExpand(codeSetValue_, coeffs_);
             dynamicCodeContext::addLineDirective
diff --git a/src/lumpedPointMotion/lumpedPointMovement.C b/src/lumpedPointMotion/lumpedPointMovement.C
index b29cc4e042..3ef592ba70 100644
--- a/src/lumpedPointMotion/lumpedPointMovement.C
+++ b/src/lumpedPointMotion/lumpedPointMovement.C
@@ -300,7 +300,7 @@ void Foam::lumpedPointMovement::readDict(const dictionary& dict)
 
     const dictionary* scaleDict = nullptr;
 
-    if ((scaleDict = commDict.subDictPtr("scaleInput")))
+    if ((scaleDict = commDict.findDict("scaleInput")))
     {
         for (int i=0; i < scaleInput_.size(); ++i)
         {
@@ -318,7 +318,7 @@ void Foam::lumpedPointMovement::readDict(const dictionary& dict)
         }
     }
 
-    if ((scaleDict = commDict.subDictPtr("scaleOutput")))
+    if ((scaleDict = commDict.findDict("scaleOutput")))
     {
         for (int i=0; i < scaleOutput_.size(); ++i)
         {
diff --git a/src/mesh/blockMesh/blockDescriptor/blockDescriptor.C b/src/mesh/blockMesh/blockDescriptor/blockDescriptor.C
index 175ecf9688..f1f6f81ccc 100644
--- a/src/mesh/blockMesh/blockDescriptor/blockDescriptor.C
+++ b/src/mesh/blockMesh/blockDescriptor/blockDescriptor.C
@@ -369,7 +369,7 @@ void Foam::blockDescriptor::write
     const dictionary& d
 )
 {
-    const dictionary* varDictPtr = d.subDictPtr("namedBlocks");
+    const dictionary* varDictPtr = d.findDict("namedBlocks");
     if (varDictPtr)
     {
         blockMeshTools::write(os, val, *varDictPtr);
diff --git a/src/mesh/blockMesh/blockMesh/blockMeshTopology.C b/src/mesh/blockMesh/blockMesh/blockMeshTopology.C
index 62f5347cf1..f136aa3d41 100644
--- a/src/mesh/blockMesh/blockMesh/blockMeshTopology.C
+++ b/src/mesh/blockMesh/blockMesh/blockMeshTopology.C
@@ -350,7 +350,7 @@ Foam::autoPtr<Foam::polyMesh> Foam::blockMesh::createTopology
     // Read the names/types for the unassigned patch faces
     // this is a bit heavy handed (and ugly), but there is currently
     // no easy way to rename polyMesh patches subsequently
-    if (const dictionary* dictPtr = meshDescription.subDictPtr("defaultPatch"))
+    if (const dictionary* dictPtr = meshDescription.findDict("defaultPatch"))
     {
         dictPtr->readIfPresent("name", defaultPatchName);
         dictPtr->readIfPresent("type", defaultPatchType);
diff --git a/src/mesh/blockMesh/blockMeshTools/blockMeshTools.C b/src/mesh/blockMesh/blockMeshTools/blockMeshTools.C
index 45eebc4956..9e5bc55a9b 100644
--- a/src/mesh/blockMesh/blockMeshTools/blockMeshTools.C
+++ b/src/mesh/blockMesh/blockMeshTools/blockMeshTools.C
@@ -42,16 +42,13 @@ void Foam::blockMeshTools::read
     else if (t.isWord())
     {
         const word& varName = t.wordToken();
-        const entry* ePtr = dict.lookupScopedEntryPtr
-        (
-            varName,
-            true,
-            true
-        );
-        if (ePtr)
+        const entry* eptr =
+            dict.findScoped(varName, keyType::REGEX_RECURSIVE);
+
+        if (eptr)
         {
             // Read as label
-            val = Foam::readLabel(ePtr->stream());
+            val = Foam::readLabel(eptr->stream());
         }
         else
         {
diff --git a/src/mesh/blockMesh/blockVertices/blockVertex/blockVertex.C b/src/mesh/blockMesh/blockVertices/blockVertex/blockVertex.C
index bf60160723..653e38dfec 100644
--- a/src/mesh/blockMesh/blockVertices/blockVertex/blockVertex.C
+++ b/src/mesh/blockMesh/blockVertices/blockVertex/blockVertex.C
@@ -104,7 +104,7 @@ Foam::autoPtr<Foam::blockVertex> Foam::blockVertex::New
 
 Foam::label Foam::blockVertex::read(Istream& is, const dictionary& dict)
 {
-    const dictionary* varDictPtr = dict.subDictPtr("namedVertices");
+    const dictionary* varDictPtr = dict.findDict("namedVertices");
     if (varDictPtr)
     {
         return blockMeshTools::read(is, *varDictPtr);
@@ -120,7 +120,7 @@ void Foam::blockVertex::write
     const dictionary& d
 )
 {
-    const dictionary* varDictPtr = d.subDictPtr("namedVertices");
+    const dictionary* varDictPtr = d.findDict("namedVertices");
     if (varDictPtr)
     {
         blockMeshTools::write(os, val, *varDictPtr);
diff --git a/src/mesh/blockMesh/blockVertices/namedVertex/namedVertex.C b/src/mesh/blockMesh/blockVertices/namedVertex/namedVertex.C
index 5e9738602e..017117e03d 100644
--- a/src/mesh/blockMesh/blockVertices/namedVertex/namedVertex.C
+++ b/src/mesh/blockMesh/blockVertices/namedVertex/namedVertex.C
@@ -53,10 +53,10 @@ Foam::blockVertices::namedVertex::namedVertex
 {
     dictionary& d = const_cast<dictionary&>(dict);
 
-    dictionary* varDictPtr = d.subDictPtr("namedVertices");
+    dictionary* varDictPtr = d.findDict("namedVertices");
     if (varDictPtr)
     {
-        const_cast<dictionary&>(*varDictPtr).add(name_, index);
+        varDictPtr->add(name_, index);
     }
     else
     {
diff --git a/src/mesh/blockMesh/blocks/namedBlock/namedBlock.C b/src/mesh/blockMesh/blocks/namedBlock/namedBlock.C
index 023638b75e..b24481803a 100644
--- a/src/mesh/blockMesh/blocks/namedBlock/namedBlock.C
+++ b/src/mesh/blockMesh/blocks/namedBlock/namedBlock.C
@@ -54,10 +54,10 @@ Foam::blocks::namedBlock::namedBlock
     block(dict, index, vertices, edges, faces, is)
 {
     dictionary& d = const_cast<dictionary&>(dict);
-    dictionary* varDictPtr = d.subDictPtr("namedBlocks");
+    dictionary* varDictPtr = d.findDict("namedBlocks");
     if (varDictPtr)
     {
-        const_cast<dictionary&>(*varDictPtr).add(*this, index);
+        varDictPtr->add(*this, index);
     }
     else
     {
diff --git a/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C b/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C
index d7a02c0f42..2476b0922e 100644
--- a/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C
+++ b/src/mesh/snappyHexMesh/meshRefinement/meshRefinementProblemCells.C
@@ -1205,7 +1205,8 @@ Foam::labelList Foam::meshRefinement::markFacesOnProblemCellsGeometric
             const labelList allFaces(identity(mesh_.nFaces()));
             label nWrongFaces = 0;
 
-            //const scalar minV(motionDict.get<scalar>("minVol", true));
+            //const scalar minV
+            //(motionDict.get<scalar>("minVol", keyType::REGEX_RECURSIVE));
             //if (minV > -GREAT)
             //{
             //    polyMeshGeometry::checkFacePyramids
diff --git a/src/mesh/snappyHexMesh/refinementSurfaces/refinementSurfaces.C b/src/mesh/snappyHexMesh/refinementSurfaces/refinementSurfaces.C
index 71a63b20f5..ec4a95b43a 100644
--- a/src/mesh/snappyHexMesh/refinementSurfaces/refinementSurfaces.C
+++ b/src/mesh/snappyHexMesh/refinementSurfaces/refinementSurfaces.C
@@ -184,7 +184,8 @@ Foam::refinementSurfaces::refinementSurfaces
     {
         const word& geomName = allGeometry_.names()[geomI];
 
-        const entry* ePtr = surfacesDict.lookupEntryPtr(geomName, false, true);
+        const entry* ePtr =
+            surfacesDict.findEntry(geomName, keyType::LITERAL);
 
         if (ePtr)
         {
diff --git a/src/mesh/snappyHexMesh/shellSurfaces/shellSurfaces.C b/src/mesh/snappyHexMesh/shellSurfaces/shellSurfaces.C
index 210a423248..8de4a57b4d 100644
--- a/src/mesh/snappyHexMesh/shellSurfaces/shellSurfaces.C
+++ b/src/mesh/snappyHexMesh/shellSurfaces/shellSurfaces.C
@@ -578,13 +578,11 @@ Foam::shellSurfaces::shellSurfaces
 
     // Count number of shells.
     label shellI = 0;
-    forAll(allGeometry.names(), geomI)
+    for (const word& geomName : allGeometry_.names())
     {
-        const word& geomName = allGeometry_.names()[geomI];
-
         if (shellsDict.found(geomName))
         {
-            shellI++;
+            ++shellI;
         }
     }
 
@@ -615,12 +613,12 @@ Foam::shellSurfaces::shellSurfaces
     {
         const word& geomName = allGeometry_.names()[geomI];
 
-        const entry* ePtr = shellsDict.lookupEntryPtr(geomName, false, true);
+        const entry* eptr = shellsDict.findEntry(geomName, keyType::LITERAL);
 
-        if (ePtr)
+        if (eptr)
         {
-            const dictionary& dict = ePtr->dict();
-            unmatchedKeys.erase(ePtr->keyword());
+            const dictionary& dict = eptr->dict();
+            unmatchedKeys.erase(eptr->keyword());
 
             shells_[shellI] = geomI;
             modes_[shellI] = refineModeNames_.lookup("mode", dict);
@@ -637,12 +635,9 @@ Foam::shellSurfaces::shellSurfaces
                 labelPair(labelMax, labelMin),
                 labelVector::zero
             );
-            const entry* levelPtr = dict.lookupEntryPtr
-            (
-                "levelIncrement",
-                false,
-                true
-            );
+            const entry* levelPtr =
+                dict.findEntry("levelIncrement", keyType::REGEX);
+
             if (levelPtr)
             {
                 // Do reading ourselves since using labelPair would require
diff --git a/src/meshTools/coordinate/systems/coordinateSystem.C b/src/meshTools/coordinate/systems/coordinateSystem.C
index 1b6cb2911d..4f80e3a8d4 100644
--- a/src/meshTools/coordinate/systems/coordinateSystem.C
+++ b/src/meshTools/coordinate/systems/coordinateSystem.C
@@ -78,7 +78,7 @@ void Foam::coordinateSystem::assign(const dictionary& dict)
     const auto finder = dict.csearchCompat
     (
         "rotation", {{"coordinateRotation", -1806}},
-        false, false
+        keyType::LITERAL
     );
 
     if (finder.isDict())
diff --git a/src/meshTools/coordinate/systems/coordinateSystemNew.C b/src/meshTools/coordinate/systems/coordinateSystemNew.C
index 13c21578ed..af2d569c7d 100644
--- a/src/meshTools/coordinate/systems/coordinateSystemNew.C
+++ b/src/meshTools/coordinate/systems/coordinateSystemNew.C
@@ -42,7 +42,7 @@ const Foam::dictionary* Foam::coordinateSystem::subDictCompat
     {
         // Non-recursive, no pattern matching in the search
         const auto finder =
-            dictPtr->csearch(coordinateSystem::typeName_(), false, false);
+            dictPtr->csearch(coordinateSystem::typeName_(), keyType::LITERAL);
 
         if (finder.isDict())
         {
diff --git a/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C b/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
index 110f57feeb..791c8d993b 100644
--- a/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
+++ b/src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C
@@ -100,7 +100,7 @@ Foam::fileName Foam::triSurfaceMesh::checkFile
 )
 {
     fileName fName;
-    if (dict.readIfPresent("file", fName, false, false))
+    if (dict.readIfPresent("file", fName, keyType::LITERAL))
     {
         fName = relativeFilePath(io, fName, isGlobal);
 
@@ -318,7 +318,7 @@ Foam::triSurfaceMesh::triSurfaceMesh
     outsideVolType_(volumeType::UNKNOWN)
 {
     // Reading from supplied file name instead of objectPath/filePath
-    if (dict.readIfPresent("file", fName_, false, false))
+    if (dict.readIfPresent("file", fName_, keyType::LITERAL))
     {
         fName_ = relativeFilePath
         (
@@ -418,7 +418,7 @@ Foam::triSurfaceMesh::triSurfaceMesh
     outsideVolType_(volumeType::UNKNOWN)
 {
     // Reading from supplied file name instead of objectPath/filePath
-    if (dict.readIfPresent("file", fName_, false, false))
+    if (dict.readIfPresent("file", fName_, keyType::LITERAL))
     {
         fName_ = relativeFilePath
         (
diff --git a/src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.C b/src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.C
index 378516e334..c354832edf 100644
--- a/src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.C
+++ b/src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.C
@@ -306,11 +306,11 @@ bool Foam::dynamicOversetFvMesh::interpolateFields()
     // Use whatever the solver has set up as suppression list
     const dictionary* dictPtr
     (
-        this->schemesDict().subDictPtr("oversetInterpolationSuppressed")
+        this->schemesDict().findDict("oversetInterpolationSuppressed")
     );
     if (dictPtr)
     {
-        suppressed.insert(dictPtr->sortedToc());
+        suppressed.insert(dictPtr->toc());
     }
 
     interpolate<volScalarField>(suppressed);
diff --git a/src/overset/oversetPolyPatch/oversetFvPatchField.C b/src/overset/oversetPolyPatch/oversetFvPatchField.C
index c60307d635..16905ef7ac 100644
--- a/src/overset/oversetPolyPatch/oversetFvPatchField.C
+++ b/src/overset/oversetPolyPatch/oversetFvPatchField.C
@@ -136,12 +136,12 @@ void Foam::oversetFvPatchField<Type>::initEvaluate
 
             const dictionary* dictPtr
             (
-                fvSchemes.subDictPtr("oversetInterpolationSuppressed")
+                fvSchemes.findDict("oversetInterpolationSuppressed")
             );
 
             if (dictPtr)
             {
-                suppressed.insert(dictPtr->sortedToc());
+                suppressed.insert(dictPtr->toc());
             }
 
             if (!suppressed.found(fldName))
diff --git a/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C b/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
index d2cec72e0b..26da76af43 100644
--- a/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
+++ b/src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C
@@ -121,7 +121,7 @@ void Foam::decompositionMethod::readConstraints()
     // Read any constraints
     wordList constraintTypes;
 
-    const dictionary* dictptr = decompositionDict_.subDictPtr("constraints");
+    const dictionary* dictptr = decompositionDict_.findDict("constraints");
 
     if (dictptr)
     {
diff --git a/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C b/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C
index 728e782cbb..da1772e30d 100644
--- a/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C
+++ b/src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.C
@@ -68,9 +68,9 @@ void Foam::multiLevelDecomp::createMethodsDict()
     if
     (
         // non-recursive, no patterns
-        coeffsDict_.readIfPresent("method", defaultMethod, false, false)
+        coeffsDict_.readIfPresent("method", defaultMethod, keyType::LITERAL)
         // non-recursive, no patterns
-     && coeffsDict_.readIfPresent("domains", domains, false, false)
+     && coeffsDict_.readIfPresent("domains", domains, keyType::LITERAL)
     )
     {
         // Short-cut version specified by method, domains only
@@ -169,14 +169,14 @@ void Foam::multiLevelDecomp::createMethodsDict()
             (
                 iter().isDict()
                 // non-recursive, no patterns
-             && iter().dict().found("numberOfSubdomains", false, false)
+             && iter().dict().found("numberOfSubdomains", keyType::LITERAL)
             )
             {
                 // No method specified? can use a default method?
 
                 const bool addDefaultMethod
                 (
-                    !(iter().dict().found("method", false, false))
+                    !(iter().dict().found("method", keyType::LITERAL))
                  && !defaultMethod.empty()
                 );
 
diff --git a/src/parallel/decompose/metisDecomp/metisDecomp.C b/src/parallel/decompose/metisDecomp/metisDecomp.C
index 43b16be9f6..5fabedf464 100644
--- a/src/parallel/decompose/metisDecomp/metisDecomp.C
+++ b/src/parallel/decompose/metisDecomp/metisDecomp.C
@@ -72,7 +72,7 @@ Foam::label Foam::metisDecomp::decomposeSerial
     word method("recursive");
 
     const dictionary* coeffsDictPtr =
-        decompositionDict_.subDictPtr("metisCoeffs");
+        decompositionDict_.findDict("metisCoeffs");
 
     label numCells = xadj.size()-1;
 
diff --git a/src/regionModels/regionModel/regionModel/regionModel.C b/src/regionModels/regionModel/regionModel/regionModel.C
index c2abb3cd23..8641753fd8 100644
--- a/src/regionModels/regionModel/regionModel/regionModel.C
+++ b/src/regionModels/regionModel/regionModel/regionModel.C
@@ -149,9 +149,9 @@ bool Foam::regionModels::regionModel::read()
     {
         if (active_)
         {
-            if (const dictionary* dictPtr = subDictPtr(modelName_ + "Coeffs"))
+            if (const dictionary* dictptr = findDict(modelName_ + "Coeffs"))
             {
-                coeffs_ <<= *dictPtr;
+                coeffs_ <<= *dictptr;
             }
 
             infoOutput_.readIfPresent("infoOutput", *this);
@@ -159,10 +159,8 @@ bool Foam::regionModels::regionModel::read()
 
         return true;
     }
-    else
-    {
-        return false;
-    }
+
+    return false;
 }
 
 
@@ -170,18 +168,16 @@ bool Foam::regionModels::regionModel::read(const dictionary& dict)
 {
     if (active_)
     {
-        if (const dictionary* dictPtr = dict.subDictPtr(modelName_ + "Coeffs"))
+        if (const dictionary* dictptr = dict.findDict(modelName_ + "Coeffs"))
         {
-            coeffs_ <<= *dictPtr;
+            coeffs_ <<= *dictptr;
         }
 
         infoOutput_.readIfPresent("infoOutput", dict);
         return true;
     }
-    else
-    {
-        return false;
-    }
+
+    return false;
 }