zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'develop' of develop.openfoam.com:Development/OpenFOAM-plus into develop

Browse Source
This commit is contained in:
sergio
2018-10-08 15:42:19 -07:00
parent ba40eeec53 3b77493abc
commit d2b32fcc84
14 changed files with 173 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
applications/test/wordRe/Test-wordRe.C
View File

@ -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.
@ -22,6 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
Test word/regex
\*---------------------------------------------------------------------------*/
@ -36,6 +37,16 @@ Description
using namespace Foam;
word typeOf(wordRe::compOption retval)
{
if (wordRe::LITERAL == retval) return "(literal)";
if (wordRe::UNKNOWN == retval) return "(unknown)";
if (wordRe::REGEX == retval) return "(regex)";
return "";
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
@ -53,28 +64,30 @@ int main(int argc, char *argv[])
{"this", wordRe::LITERAL},
{"x.*", wordRe::REGEX},
{"file[a-b]", wordRe::REGEX},
{"xvalues", wordRe::LITERAL},
{"xv.*", wordRe::REGEX},
};
if (true)
if (false)
{
Info<<"keyType: " << keyre << endl;
Info<<"keyType: " << keyre << nl;
keyType key2(std::move(keyre));
Info<<"move construct: <" << keyre << "> <" << key2 << ">" << endl;
Info<<"move construct: <" << keyre << "> <" << key2 << ">" << nl;
keyre = std::move(key2);
Info<<"move assign: <" << keyre << "> <" << key2 << ">" << endl;
Info<<"move assign: <" << keyre << "> <" << key2 << ">" << nl;
keyType key3;
keyre.swap(key3);
Info<<"swap: <" << keyre << "> <" << key3 << ">" << endl;
Info<<"swap: <" << keyre << "> <" << key3 << ">" << nl;
keyre = std::move(key3);
Info<<"move assign: <" << keyre << "> <" << key3 << ">" << endl;
Info<<"move assign: <" << keyre << "> <" << key3 << ">" << nl;
return 0;
}
@ -83,86 +96,92 @@ int main(int argc, char *argv[])
{
wordRe keyre("y.*", wordRe::REGEX);
Info<<"wordRe: " << keyre << endl;
Info<<"wordRe: " << keyre << nl;
wordRe key2(std::move(keyre));
Info<<"keyTypes: " << keyre << " " << key2 << endl;
Info<<"keyTypes: " << keyre << " " << key2 << nl;
keyre = std::move(key2);
Info<<"keyTypes: " << keyre << " " << key2 << endl;
Info<<"keyTypes: " << keyre << " " << key2 << nl;
wordRe key3;
keyre.swap(key3);
Info<<"keyTypes: <" << keyre << "> <" << key3 << ">" << endl;
Info<<"keyTypes: <" << keyre << "> <" << key3 << ">" << nl;
keyre = std::move(key3);
Info<<"keyTypes: <" << keyre << "> <" << key3 << ">" << endl;
Info<<"keyTypes: <" << keyre << "> <" << key3 << ">" << nl;
return 0;
}
wordRes wrelist(wordrelist);
wordRes wres1(wordrelist);
Info<< "re-list:" << wrelist << endl;
Info<< "match this: " << wrelist("this") << endl;
Info<< "match xyz: " << wrelist("xyz") << endl;
Info<< "match zyx: " << wrelist("zyx") << endl;
Info<< "match xyz: " << wrelist.match("xyz") << endl;
Info<< "match any: " << predicates::always()("any junk") << endl;
Info<< "keyre match: " << keyre("xyz") << endl;
Info<< "string match: " << string("this").match("xyz") << endl;
Info<< "string match: " << string("x.*")("xyz") << endl;
Info<< "string match: " << string("x.*")(keyre) << endl;
Info<< "re-list:" << wres1 << nl;
Info<< "match this: " << wres1("this") << nl;
Info<< "match xyz: " << wres1("xyz") << nl;
Info<< "match zyx: " << wres1("zyx") << nl;
Info<< "match xyz: " << wres1.match("xyz") << nl;
Info<< "match any: " << predicates::always()("any junk") << nl;
wordRe(s1, wordRe::DETECT).info(Info) << endl;
wordRe(s2).info(Info) << endl;
wordRe(s2, wordRe::DETECT).info(Info) << endl;
wordRe(s3, wordRe::REGEX).info(Info) << endl;
Info<< "match xvalues: " << wres1.match("xvalues") << nl;
Info<< "matched xvalues = " << typeOf(wres1.matched("xvalues")) << nl;
Info<< "matched xval = " << typeOf(wres1.matched("xval")) << nl;
Info<< "matched zyx = " << typeOf(wres1.matched("zyx")) << nl;
Info<< "keyre match: " << keyre("xyz") << nl;
Info<< "string match: " << string("this").match("xyz") << nl;
Info<< "string match: " << string("x.*")("xyz") << nl;
Info<< "string match: " << string("x.*")(keyre) << nl;
wordRe(s1, wordRe::DETECT).info(Info) << nl;
wordRe(s2).info(Info) << nl;
wordRe(s2, wordRe::DETECT).info(Info) << nl;
wordRe(s3, wordRe::REGEX).info(Info) << nl;
wre = "this .* file";
Info<<"substring: " << wre.substr(4) << endl;
Info<<"substring: " << wre.substr(4) << nl;
wre.info(Info) << endl;
wre.info(Info) << nl;
wre = s1;
wre.info(Info) << endl;
wre.info(Info) << nl;
wre.uncompile();
wre.info(Info) << endl;
wre.info(Info) << nl;
wre = "something";
wre.info(Info) << " before" << endl;
wre.info(Info) << " before" << nl;
wre.uncompile();
wre.info(Info) << " uncompiled" << endl;
wre.info(Info) << " uncompiled" << nl;
wre.compile(wordRe::DETECT);
wre.info(Info) << " after DETECT" << endl;
wre.info(Info) << " after DETECT" << nl;
wre.compile(wordRe::ICASE);
wre.info(Info) << " after ICASE" << endl;
wre.info(Info) << " after ICASE" << nl;
wre.compile(wordRe::DETECT_ICASE);
wre.info(Info) << " after DETECT_ICASE" << endl;
wre.info(Info) << " after DETECT_ICASE" << nl;
wre = "something .* value";
wre.info(Info) << " before" << endl;
wre.info(Info) << " before" << nl;
wre.uncompile();
wre.info(Info) << " uncompiled" << endl;
wre.info(Info) << " uncompiled" << nl;
wre.compile(wordRe::DETECT);
wre.info(Info) << " after DETECT" << endl;
wre.info(Info) << " after DETECT" << nl;
wre.uncompile();
wre.info(Info) << " uncompiled" << endl;
wre.info(Info) << " uncompiled" << nl;
wre.compile();
wre.info(Info) << " re-compiled" << endl;
wre.info(Info) << " re-compiled" << nl;
wre.set("something .* value", wordRe::LITERAL);
wre.info(Info) << " set as LITERAL" << endl;
wre.info(Info) << " set as LITERAL" << nl;
IOobject::writeDivider(Info);
List<Tuple2<wordRe, string>> rawList(IFstream("testRegexps")());
Info<< "input list:" << rawList << endl;
IOobject::writeDivider(Info) << endl;
Info<< "input list:" << rawList << nl;
IOobject::writeDivider(Info) << nl;
forAll(rawList, elemI)
{
@ -174,7 +193,7 @@ int main(int argc, char *argv[])
<< "(" << wre.match(str, true) << ")"
<< " match:" << wre.match(str)
<< " str=" << str
<< endl;
<< nl;
wordRe wre2;
wre2.set(wre, wordRe::ICASE);
@ -182,11 +201,11 @@ int main(int argc, char *argv[])
wre2.info(Info)
<< " match:" << wre2.match(str)
<< " str=" << str
<< endl;
<< nl;
}
Info<< endl;
Info<< "\nEnd\n" << endl;
return 0;
}

2
applications/utilities/mesh/manipulation/subsetMesh/subsetMesh.C
View File

@ -440,7 +440,7 @@ int main(int argc, char *argv[])
{
const wordRes patchNames(args.getList<wordRe>("patches"));
if (patchNames.size() == 1 && !patchNames.first().isPattern())
if (patchNames.size() == 1 && patchNames.first().isLiteral())
{
exposedPatchIDs.first() =
getExposedPatchId(mesh, patchNames.first());

2
src/OpenFOAM/db/dictionary/functionEntries/removeEntry/removeEntry.C
View File

@ -58,7 +58,7 @@ bool Foam::functionEntries::removeEntry::execute
for (const keyType& key : patterns)
{
if (key.find('/') != string::npos || !key.isPattern())
if (key.isLiteral() && key.find('/') != string::npos)
{
// Remove scoped keyword, or keyword in the local scope
dictionary::searcher finder =

4
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
View File

@ -53,7 +53,7 @@ readField
// patch name since is key of dictionary.
forAllConstIter(dictionary, dict, iter)
{
if (iter().isDict() && !iter().keyword().isPattern())
if (iter().isDict() && iter().keyword().isLiteral())
{
const label patchi = bmesh_.findPatchID(iter().keyword());
@ -96,7 +96,7 @@ readField
{
const entry& e = iter();
if (e.isDict() && !e.keyword().isPattern())
if (e.isDict() && e.keyword().isLiteral())
{
const labelList patchIds =
bmesh_.indices(e.keyword(), true); // use patchGroups

23
src/OpenFOAM/primitives/strings/keyType/keyType.H
View File

@ -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.
@ -29,8 +29,7 @@ Description
A keyType is the keyword of a dictionary.
It differs from word in that it also accepts patterns (regular expressions).
It is very similar to wordRe, but doesn't store the regular expression
separately.
It is very similar to wordRe, but doesn't store a regular expression.
SourceFiles
keyType.C
@ -47,12 +46,10 @@ SourceFiles
namespace Foam
{
// Forward declaration of classes
// Forward declarations
class keyType;
class Istream;
class Ostream;
// Forward declaration of friend functions and operators
class keyType;
Istream& operator>>(Istream& is, keyType& kw);
Ostream& operator<<(Ostream& os, const keyType& kw);
@ -70,6 +67,7 @@ class keyType
//- Is the keyType a pattern (regular expression)
bool isPattern_;
// Private Member Functions
//- No assignment where we cannot determine string/word type
@ -121,14 +119,17 @@ public:
keyType(Istream& is);
// Member functions
// Member Functions
//- Is this character valid for a keyType?
// This is largely identical with what word accepts, but also
// permit brace-brackets, which are valid for some regexs.
inline static bool valid(char c);
//- Treat as a pattern rather than a literal string?
//- The keyType is treated as literal, not as pattern.
inline bool isLiteral() const;
//- The keyType is treated as a pattern, not as literal string.
inline bool isPattern() const;
//- Swap contents
@ -139,7 +140,7 @@ public:
bool match(const std::string& text, bool literal = false) const;
// Member operators
// Member Operators
//- Perform smart match on text, as per match()
// Allows use as a predicate.
@ -162,7 +163,7 @@ public:
inline void operator=(const char* s);
// IOstream operators
// IOstream Operators
friend Istream& operator>>(Istream& is, keyType& kw);
friend Ostream& operator<<(Ostream& os, const keyType& kw);

7
src/OpenFOAM/primitives/strings/keyType/keyTypeI.H
View File

@ -84,7 +84,6 @@ inline Foam::keyType::keyType(const std::string& s, const bool isPattern)
{}
inline Foam::keyType::keyType(keyType&& s)
:
word(std::move(static_cast<word&>(s)), false),
@ -117,6 +116,12 @@ inline Foam::keyType::keyType(std::string&& s, const bool isPattern)
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline bool Foam::keyType::isLiteral() const
{
return !isPattern_;
}
inline bool Foam::keyType::isPattern() const
{
return isPattern_;

13
src/OpenFOAM/primitives/strings/wordRe/wordRe.H
View File

@ -59,7 +59,7 @@ SourceFiles
namespace Foam
{
// Forward declaration of friend functions and operators
// Forward declarations
class wordRe;
class Istream;
class Ostream;
@ -81,6 +81,7 @@ class wordRe
//- The regular expression
mutable regExp re_;
public:
// Static data members
@ -97,6 +98,7 @@ public:
{
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)
@ -163,11 +165,14 @@ public:
wordRe(Istream& is);
// Member functions
// Member Functions
// Access
//- Treat as a pattern rather than a literal string?
//- The wordRe is treated as literal, not as pattern.
inline bool isLiteral() const;
//- The wordRe is treated as a pattern, not as literal string.
inline bool isPattern() const;
@ -248,7 +253,7 @@ public:
inline void operator=(wordRe&& str);
// IOstream operators
// IOstream Operators
friend Istream& operator>>(Istream& is, wordRe& w);
friend Ostream& operator<<(Ostream& os, const wordRe& w);

8
src/OpenFOAM/primitives/strings/wordRe/wordReI.H
View File

@ -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.
@ -157,6 +157,12 @@ inline Foam::wordRe::wordRe(const word& str, const compOption opt)
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline bool Foam::wordRe::isLiteral() const
{
return !re_.exists();
}
inline bool Foam::wordRe::isPattern() const
{
return re_.exists();

34
src/OpenFOAM/primitives/strings/wordRes/wordRes.H
View File

@ -53,7 +53,7 @@ class wordRes
{
// Private Methods
//- Check for any match of text in list of matchers
//- Smart match as literal or regex, stopping on the first match.
inline static bool found_match
(
const UList<wordRe>& patterns,
@ -61,6 +61,17 @@ class wordRes
bool literal=false
);
//- Smart match across entire list, returning the match type.
// Stops on the first literal match, or continues to examine
// if a regex match occurs.
// \return wordRe::LITERAL, wordRe::REGEX on match and
// wordRe::UNKNOWN otherwise.
inline static wordRe::compOption found_matched
(
const UList<wordRe>& patterns,
const std::string& text
);
public:
@ -111,16 +122,23 @@ public:
// No filtering attempted on regular expressions.
void uniq();
//- Return true if string matches ANY of the regular expressions
// Smart match as regular expression or as a string.
// Optionally force a literal match only
inline bool match(const std::string& text, bool literal=false) const;
//- Smart match as literal or regex, stopping on the first match.
//
// \param literal Force literal match only.
// \return True if text matches ANY of the entries.
inline bool match(const std::string& text, bool literal = false) const;
//- Smart match in the list of matchers, returning the match type.
// It stops if there is a literal match, or continues to examine
// other regexs.
// \return LITERAL if a lteral match was found, REGEX if a regex
// match was found and UNKNOWN otherwise.
inline wordRe::compOption matched(const std::string& text) const;
// Member operators
// Member Operators
//- Perform smart match on text, as per match()
// Allows use as a predicate.
//- Identical to match(), for use as a predicate.
inline bool operator()(const std::string& text) const;
};

37
src/OpenFOAM/primitives/strings/wordRes/wordResI.H
View File

@ -50,6 +50,36 @@ inline bool Foam::wordRes::found_match
}
inline Foam::wordRe::compOption Foam::wordRes::found_matched
(
const UList<wordRe>& patterns,
const std::string& text
)
{
auto retval(wordRe::compOption::UNKNOWN);
for (const wordRe& select : patterns)
{
if (select.isLiteral())
{
if (select.match(text, true))
{
return wordRe::compOption::LITERAL;
}
}
else if (wordRe::compOption::UNKNOWN == retval)
{
if (select.match(text, false))
{
retval = wordRe::compOption::REGEX;
}
}
}
return retval;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline bool Foam::wordRes::match(const std::string& text, bool literal) const
@ -58,6 +88,13 @@ inline bool Foam::wordRes::match(const std::string& text, bool literal) const
}
inline Foam::wordRe::compOption
Foam::wordRes::matched(const std::string& text) const
{
return found_matched(*this, text);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
inline bool Foam::wordRes::operator()(const std::string& text) const

2
src/OpenFOAM/primitives/transform/transform.H
View File

@ -170,7 +170,7 @@ inline label invTransform(const tensor&, const label i)
}
//- No-op rotational transform of a label
//- No-op rotational transform of a scalar
inline scalar transform(const tensor&, const scalar s)
{
return s;

4
src/functionObjects/field/ddt2/ddt2.C
View File

@ -174,9 +174,9 @@ bool Foam::functionObjects::ddt2::execute()
// Check exact matches first
for (const wordRe& select : selectFields_)
{
if (!select.isPattern())
if (select.isLiteral())
{
const word& fieldName = static_cast<const word&>(select);
const word& fieldName = select;
if (!candidates.erase(fieldName))
{

4
src/functionObjects/field/zeroGradient/zeroGradient.C
View File

@ -133,9 +133,9 @@ bool Foam::functionObjects::zeroGradient::execute()
// Check exact matches first
for (const wordRe& select : selectFields_)
{
if (!select.isPattern())
if (select.isLiteral())
{
const word& fieldName = static_cast<const word&>(select);
const word& fieldName = select;
if (!candidates.erase(fieldName))
{

2
src/functionObjects/utilities/ensightWrite/ensightWrite.C
View File

@ -284,7 +284,7 @@ bool Foam::functionObjects::ensightWrite::write()
// Check exact matches first
for (const wordRe& select : selectFields_)
{
if (!select.isPattern())
if (select.isLiteral())
{
const word& fieldName = select;