diff --git a/applications/test/dictionary/Test-dictionary.C b/applications/test/dictionary/Test-dictionary.C
index 393aafe482298623327dd221e5c6917d795fabdc..bddadce6fe6d0b95c6e6563d5317d6e609530029 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 c844c8286b989d0a8bc6a14047952bb908940e91..f3ed8436804b3e01234d51dd4e0e95df68c47df9 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 740b807f40b44d84d26af393c79c8c3b91a81e95..ca4e3280e3913195537e92cb739724a4a27b41a0 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 00bad93cd888b6c2ae008d252f06b23fe1028e2c..d6f1256074a2fefa942e263a98a0f09237e27ab9 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 bc71e6d0f197262f86b0771395344a3f22b3fe3e..fba263b46436bfaf4e236d5de9653a5c74045e45 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 5daa5766fe63067bdfd7ea7d878579441aadefae..5a7da19bb7b49804bee952a577a9b6de71c5916c 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 dee2956e076d2cfbb4dbae5cbd5f72aacc5b02a3..ce2e7ae1017358e5681e1d1f63983f06e4ac5d78 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 920ba165a57e2f3e8217902eeed0e41831dc3b54..357c889d8a31a4596c0162aeb2a5760519121775 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 8a39925f4fb0b32c7c15bfa0e318a2686e13077c..4e86ce0af933ec2a1c9ddd8a60d0b5b5e955f3da 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 d85d0e338988f96f0b957a167cbf837acd0f9619..51b3819f88b8e76e614d311dfefd8305c93d5ac3 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 9fb3cc0c703e50ac31cd90983e728424c27073ba..ea45f1b2f38e7777bbcc91a40b55d5700c28b3ce 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 125c73e127941f86ab595f1ed1a1ef8597fe20b2..4cdc9a754c3d364ad7e54a2cc3ce4c1e99420cae 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();
+}
+
+
+Foam::entry* Foam::dictionary::findEntry
+(
+ const word& keyword,
+ enum keyType::option matchOpt
+)
+{
+ return search(keyword, matchOpt).ptr();
}
-const Foam::entry* Foam::dictionary::lookupEntryPtr
+const Foam::entry* Foam::dictionary::findEntry
(
const word& keyword,
- bool recursive,
- bool patternMatch
+ enum keyType::option matchOpt
) const
{
- return csearch(keyword, recursive, patternMatch).ptr();
+ return csearch(keyword, matchOpt).ptr();
}
-Foam::entry* Foam::dictionary::lookupEntryPtr
+const Foam::entry* Foam::dictionary::findScoped
(
const word& keyword,
- bool recursive,
- bool patternMatch
-)
+ enum keyType::option matchOpt
+) const
{
- return search(keyword, recursive, patternMatch).ptr();
+ 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 6364c722cbad7a196add9626043c9adaeed39529..b031835b00bf448a3bbf90297dbd6cb793988915 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
+ enum keyType::option matchOpt = keyType::REGEX
+ );
+
+ //- Find an entry (const access) with the given keyword.
+ //
+ // \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;
- //- Find and return an entry pointer for manipulation if present,
- //- or return a nullptr.
+ //- 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 recursive search parent dictionaries
- // \param patternMatch use regular expressions
- entry* lookupEntryPtr
+ // \param matchOpt the default search is non-recursive with patterns
+ //
+ // \return the entry pointer found or a nullptr.
+ const entry* findScoped
(
const word& keyword,
- bool recursive,
- bool patternMatch
+ 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
);
- //- Find and return an entry if present, otherwise FatalIOError.
+ //- 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 recursive search parent dictionaries
- // \param patternMatch use regular expressions
+ // \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
- ) const;
-
- //- Find and return a T.
- //- FatalIOError if not found, or if there are excess tokens.
- // Default search: non-recursive with patterns.
- //
- // \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
+ enum keyType::option matchOpt = keyType::REGEX
) 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.
+ //- 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
+ // \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
- ) 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
+ enum keyType::option matchOpt = keyType::REGEX
) 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 49fb277fb54ac7c8519e1db66348a69cdb510626..c16f7de0d876c7fd0089908f5f082a8532ef2a8e 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 7a51ae2d6754fcce5296ef31e62c675aaac3dc87..de4ff879aa23cf3e6b70b52261017c62ef4a39b6 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 4c8ec03c07832be83cb7c6e701e3b2da4d87b847..902d10f07da59823cda922eb3620f934ca308899 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 fab47e648891b2e09ac68aef6cdeac7a22543bae..a8656dcb08554dc231d4a3ef0d98740807405f63 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 0e50a68e9b3ace8ac6e95b06eaaf649325a1ed95..cd7a335c0baf7ce7514ab8951824bcb974d2158a 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 25e452fce368657265be07f744cb6428594ea014..2a216f5c5f97cf8e903ec4db083cfcc85ce520c3 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 0998353e9fad892451457c2ee4a4c453d13ec5e0..3c8715a2c087e733febf43fa48fc64a56cb1a20b 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 f7dabea32c4f23065b7ef64e89284ae98fd70db0..0cbb02b7a2ca7e04d211a3b8967988616259e596 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 6f410788678516adb24031475dd6e4fb5d0652c2..a626aa78740ca1e7ea1d599e41c630286335311d 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 db9902b94f27dc549833b8d8416a0b66ebe276c9..2fd7f11563d2bbf52627c20e9f73b48160c5e6b1 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 2b7206cc4fee8f5d93ab9d9161ba8c8ca4cb3f4e..d9102084f1d644e87d9cb8626c64a079cb121d0f 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 03cf4bc80c5022a1322e95fe78adda2a91f16ac0..a06170d7092e96e0bfea4111403c45dc5737f2e4 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 892f6569d1c22e98910a930479c5d54456e93d14..88a1f86380f36c234d98082a6f79e81d98c6306f 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 33990232184b0b5b1f53d155e2a4e7e4aafdaf92..0e1bbaa01593e061c71399203ae63c71ea839283 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 b08dde5b91e17eb50c7f250e2b90f43d1113df69..b2a3a07800db5935bcf45dfa368089a9d2027a8a 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 fe97b5acc2228264919f14c18e7b57fe083a7508..9063d21f83166435f22b9431ef3a5e97068241d6 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 608468105f96132a545672dc8559990b634987ed..cf9db5128f9f44ca98123af4d1b0cdec290737f7 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 bf84de6a2384888d2ee825e5a1d71b6d7052a510..3b4b0f3289508f75b88099c2d1fe3eb77ec1ef70 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 484ef5f9f5ed7e7f24e7b433b3efd8b2cf1fd49d..325e64051dbe28aa2db9d16844cb7938ee6d3578 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 9976ecb6dce27419a551067fe10e4bebef96e077..5b83bda346eb9f8b11b3e270ed756ba2f0df65ba 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 8a5aadee53fdc43202d0f664ecb5bd5e05c40504..361fbe216e106ecb567c0907283538a8e44821cc 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 c403486a2c763fc28e73c74d80d84b4e4d7ea205..e8b4d8551a9c137d743299d4bf461b558c986a29 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 62d65ffaf3095f44f5c29ba7ff8b6ce39545489e..6b4136d384865713664c69cb0ef8f48f6dc29f23 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 bf27297e0e1da451eb23d7aa4da01b4f5967db04..8cbeeecda217a3a797da6e44f9e037b959fd284c 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 b29cc4e042ee3c967d71f652cc67967aa7c97536..3ef592ba709b080a7ea230ace402b26ef2a4b929 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 175ecf96888184028224cedf90e0a71afef86f04..f1f6f81cccee4e158cce0b411141dcab90fa04b7 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 62f5347cf14f7500c446de31ac7c093a861a1194..f136aa3d4167c7ed9cbefbe7d791362c82b09f20 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 45eebc495645407c26d80a182a9cc29aac4e7c93..9e5bc55a9bea0664775476468f8e6bf50f679463 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 bf6016072324419ad1ff4bb457c9b93364365e87..653e38dfec08a3d4c7d9b8e807f3fddf1c534944 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 5e9738602ed1b53ee84fd9c94a20684b09d50378..017117e03d205fc440e9d648292e6afb1dbdd643 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 023638b75ed724d2d7ee2f354c3fb1a8718ab212..b24481803a7bff3899763333255afefcbab60282 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 d7a02c0f42807c7261d2cce3370535c06eecb625..2476b0922e7786934c4dd9a0ce2c7662df88af6b 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 71a63b20f5ba83853ed08ba18d32667ec1c6d250..ec4a95b43aa5cf7c8fa84d9230866b2cdb2b77b5 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 210a42324841488f8944417471ff8515ccfafd59..8de4a57b4d9f98b9a5a91d647de392360c11feb9 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 1b6cb2911dd8f85aa6f9062e443b2b3d767fdf9f..4f80e3a8d45949ec7c3941a054c81978fad47b12 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 13c21578edaa77594bc34fd5ea772597d57f322f..af2d569c7dbd40f226ff38586b23e0d68ada04f6 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 110f57feeb9b75ccdf069d64022a7dc4c689b01b..791c8d993ba4ac9e3e5c56bcee703262c8982dec 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 378516e3341175720c91123c042e61967a340fad..c354832edfa9dde710f9aba487bda355209afad5 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 c60307d63582c05c7aff0e97c690d3e573279923..16905ef7ac530f69289df79cb6a7c1cce4994105 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 d2cec72e0b3f3d5a8cb90b71540f9b8f11206136..26da76af43a28c712ae24824f2c063f64662b803 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 728e782cbbaea97c4adafd55b58582102f99a4fc..da1772e30df9936dd676fa47ff368ab2707c6883 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 43b16be9f66f16e58709f26037e6a7d4dc5e6727..5fabedf464a5d046b763da1f4d5ef39ae8c38acc 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 c2abb3cd236b276336d752491ccf7d17544165cf..8641753fd8c3619388737bc0e4dd26e012156f15 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;
}