Merge remote-tracking branch 'origin/develop' into develop

applications/utilities/miscellaneous/foamDictionary/foamDictionary.C

@@ -129,6 +129,7 @@ Usage
 #include "Fstream.H"
 #include "etcFiles.H"
 #include "includeEntry.H"
+#include "foamVersion.H"
 
 using namespace Foam;
 
@@ -328,6 +329,9 @@ int main(int argc, char *argv[])
 
     argList args(argc, argv);
 
+    // OPENFOAM API
+    setEnv("FOAM_API", std::to_string(foamVersion::api), true);
+
     const bool listIncludes = args.found("includes");
 
     if (listIncludes)

applications/utilities/postProcessing/graphics/PVReaders/vtkPVFoam/vtkPVFoamUpdateInfo.C

@@ -232,7 +232,7 @@ void Foam::vtkPVFoam::updateInfoLagrangian
     {
         names.insert
         (
-            readDir
+            fileHandler().readDir
             (
                 dbPtr_->path()/t.name()/lagrangianPrefix,
                 fileName::DIRECTORY

src/OpenFOAM/Make/files

@@ -244,6 +244,8 @@ $(functionEntries)/includeEtcEntry/includeEtcEntry.C
 $(functionEntries)/includeFuncEntry/includeFuncEntry.C
 $(functionEntries)/inputMode/inputMode.C
 $(functionEntries)/removeEntry/removeEntry.C
+$(functionEntries)/ifeqEntry/ifeqEntry.C
+$(functionEntries)/ifEntry/ifEntry.C
 
 IOdictionary = db/IOobjects/IOdictionary
 $(IOdictionary)/baseIOdictionary.C

src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.C

@@ -34,6 +34,7 @@ License
 #include "SubList.H"
 #include "labelPair.H"
 #include "masterUncollatedFileOperation.H"
+#include "IListStream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -177,10 +178,9 @@ bool Foam::decomposedBlockData::readMasterHeader(IOobject& io, Istream& is)
 
     List<char> data(is);
     is.fatalCheck("read(Istream&) : reading entry");
-    string buf(data.begin(), data.size());
-    IStringStream str
+    IListStream str
     (
-        buf,
+        std::move(data),
         IOstream::ASCII,
         IOstream::currentVersion,
         is.name()
@@ -261,12 +261,11 @@ Foam::autoPtr<Foam::ISstream> Foam::decomposedBlockData::readBlock
         is >> data;
         is.fatalCheck("read(Istream&) : reading entry");
 
-        string buf(data.begin(), data.size());
         realIsPtr.reset
         (
-            new IStringStream
+            new IListStream
             (
-                buf,
+                std::move(data),
                 IOstream::ASCII,
                 IOstream::currentVersion,
                 is.name()
@@ -290,10 +289,9 @@ Foam::autoPtr<Foam::ISstream> Foam::decomposedBlockData::readBlock
         IOstream::versionNumber ver(IOstream::currentVersion);
         IOstream::streamFormat fmt;
         {
-            string buf(data.begin(), data.size());
-            IStringStream headerStream
+            UIListStream headerStream
             (
-                buf,
+                data,
                 IOstream::ASCII,
                 IOstream::currentVersion,
                 is.name()
@@ -316,12 +314,11 @@ Foam::autoPtr<Foam::ISstream> Foam::decomposedBlockData::readBlock
             is >> data;
             is.fatalCheck("read(Istream&) : reading entry");
         }
-        string buf(data.begin(), data.size());
         realIsPtr.reset
         (
-            new IStringStream
+            new IListStream
             (
-                buf,
+                std::move(data),
                 IOstream::ASCII,
                 IOstream::currentVersion,
                 is.name()
@@ -489,18 +486,18 @@ Foam::autoPtr<Foam::ISstream> Foam::decomposedBlockData::readBlocks
                 is >> data;
                 is.fatalCheck("read(Istream&) : reading entry");
 
-                string buf(data.begin(), data.size());
                 realIsPtr.reset
                 (
-                    new IStringStream
+                    new IListStream
                     (
-                        buf,
+                        std::move(data),
                         IOstream::ASCII,
                         IOstream::currentVersion,
                         fName
                     )
                 );
 
+
                 // Read header
                 if (!headerIO.readHeader(realIsPtr()))
                 {
@@ -546,12 +543,11 @@ Foam::autoPtr<Foam::ISstream> Foam::decomposedBlockData::readBlocks
             );
             is >> data;
 
-            string buf(data.begin(), data.size());
             realIsPtr.reset
             (
-                new IStringStream
+                new IListStream
                 (
-                    buf,
+                    std::move(data),
                     IOstream::ASCII,
                     IOstream::currentVersion,
                     fName
@@ -578,12 +574,11 @@ Foam::autoPtr<Foam::ISstream> Foam::decomposedBlockData::readBlocks
                 is >> data;
                 is.fatalCheck("read(Istream&) : reading entry");
 
-                string buf(data.begin(), data.size());
                 realIsPtr.reset
                 (
-                    new IStringStream
+                    new IListStream
                     (
-                        buf,
+                        std::move(data),
                         IOstream::ASCII,
                         IOstream::currentVersion,
                         fName
@@ -625,12 +620,11 @@ Foam::autoPtr<Foam::ISstream> Foam::decomposedBlockData::readBlocks
             UIPstream is(UPstream::masterNo(), pBufs);
             is >> data;
 
-            string buf(data.begin(), data.size());
             realIsPtr.reset
             (
-                new IStringStream
+                new IListStream
                 (
-                    buf,
+                    std::move(data),
                     IOstream::ASCII,
                     IOstream::currentVersion,
                     fName
@@ -1038,18 +1032,14 @@ bool Foam::decomposedBlockData::writeData(Ostream& os) const
 {
     const List<char>& data = *this;
 
-    string str
-    (
-        reinterpret_cast<const char*>(data.cbegin()),
-        data.byteSize()
-    );
-
     IOobject io(*this);
+
+    // Re-read my own data to find out the header information
     if (Pstream::master(comm_))
     {
-        IStringStream is
+        UIListStream is
         (
-            str,
+            data,
             IOstream::ASCII,
             IOstream::currentVersion,
             name()
@@ -1097,6 +1087,11 @@ bool Foam::decomposedBlockData::writeData(Ostream& os) const
         );
     }
 
+    string str
+    (
+        reinterpret_cast<const char*>(data.cbegin()),
+        data.byteSize()
+    );
     os.writeQuoted(str, false);
 
     if (!Pstream::master(comm_))

src/OpenFOAM/db/dictionary/functionEntries/README

@@ -17,6 +17,8 @@
                     |                   |
   #calc             | dict/primitive    | string
   #codeStream       | dict/primitive    | dictionary
+  #if               | dict              | string
+  #ifeq             | dict              | entry entry
 
 
 Pending future extensions

src/OpenFOAM/db/dictionary/functionEntries/ifEntry/ifEntry.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ifEntry.H"
+#include "Switch.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionEntries
+{
+    defineTypeNameAndDebug(ifEntry, 0);
+
+    addNamedToMemberFunctionSelectionTable
+    (
+        functionEntry,
+        ifEntry,
+        execute,
+        dictionaryIstream,
+        if
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::functionEntries::ifEntry::execute
+(
+    DynamicList<filePos>& stack,
+    dictionary& parentDict,
+    Istream& is
+)
+{
+    const label nNested = stack.size();
+
+    stack.append(filePos(is.name(), is.lineNumber()));
+
+    // Read line
+    string line;
+    dynamic_cast<ISstream&>(is).getLine(line);
+    line += ';';
+    IStringStream lineStream(line);
+    const primitiveEntry e("ifEntry", parentDict, lineStream);
+    const Switch doIf(e.stream());
+
+    // Info<< "Using #" << typeName << " " << doIf
+    //     << " at line " << stack.last().second()
+    //     << " in file " <<  stack.last().first() << endl;
+
+    bool ok = ifeqEntry::execute(doIf, stack, parentDict, is);
+
+    if (stack.size() != nNested)
+    {
+        FatalIOErrorInFunction(parentDict)
+            << "Did not find matching #endif for condition starting"
+            << " at line " << stack.last().second()
+            << " in file " <<  stack.last().first() << exit(FatalIOError);
+    }
+
+    return ok;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::functionEntries::ifEntry::execute
+(
+    dictionary& parentDict,
+    Istream& is
+)
+{
+    DynamicList<filePos> stack(10);
+    return execute(stack, parentDict, is);
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/db/dictionary/functionEntries/ifEntry/ifEntry.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::functionEntries::ifEntry
+
+Description
+    Conditional parsing of dictionary entries.
+
+    E.g.
+    \verbatim
+        U_inlet 15;
+
+        #if #calc "${U_inlet} < 10"
+            ..
+        #else
+            ..
+        #endif
+    \endverbatim
+
+    Note:
+    - only supports single line, '\' is not supported
+    - condition should be readable as a \c Switch
+      (supports 0,1, true, false, etc.)
+
+See also
+    Foam::functionEntries::ifeqEntry
+    Foam::Switch
+
+SourceFiles
+    ifEntry.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ifEntry_H
+#define ifEntry_H
+
+#include "ifeqEntry.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionEntries
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class ifEntry Declaration
+\*---------------------------------------------------------------------------*/
+
+class ifEntry
+:
+    public ifeqEntry
+{
+    friend class ifeqEntry;
+
+    // Private Member Functions
+
+        //- Execute the functionEntry in a sub-dict context
+        static bool execute
+        (
+            DynamicList<filePos>& stack,
+            dictionary& parentDict,
+            Istream& is
+        );
+
+        //- Disallow default bitwise copy construct
+        ifEntry(const ifEntry&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const ifEntry&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("if");
+
+    // Member Functions
+
+        //- Execute the functionEntry in a sub-dict context
+        static bool execute(dictionary& parentDict, Istream& is);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace functionEntries
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/db/dictionary/functionEntries/ifeqEntry/ifeqEntry.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ifeqEntry.H"
+#include "stringOps.H"
+#include "ifEntry.H"
+#include "Switch.H"
+#include "addToMemberFunctionSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionEntries
+{
+    defineTypeNameAndDebug(ifeqEntry, 0);
+
+    addNamedToMemberFunctionSelectionTable
+    (
+        functionEntry,
+        ifeqEntry,
+        execute,
+        dictionaryIstream,
+        ifeq
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::functionEntries::ifeqEntry::readToken(token& t, Istream& is)
+{
+    // Skip dummy tokens - avoids entry::getKeyword consuming #else, #endif
+    do
+    {
+        if
+        (
+            is.read(t).bad()
+         || is.eof()
+         || !t.good()
+        )
+        {
+            return;
+        }
+    }
+    while (t == token::END_STATEMENT);
+}
+
+
+Foam::token Foam::functionEntries::ifeqEntry::expand
+(
+    const dictionary& dict,
+    const string& keyword,
+    const token& t
+)
+{
+    if (keyword[0] == '$')
+    {
+        const word varName(keyword.substr(1, keyword.size()-1));
+
+        // lookup the variable name in the given dictionary
+        const entry* ePtr = dict.lookupScopedEntryPtr
+        (
+            varName,
+            true,
+            true
+        );
+        if (ePtr)
+        {
+            return token(ePtr->stream());
+        }
+        else
+        {
+            // String expansion. Allow unset variables
+            string expanded(keyword);
+            stringOps::inplaceExpand(expanded, dict, true, true);
+
+            // Re-form as a string token so we can compare to string
+            return token(expanded, t.lineNumber());
+        }
+    }
+    else if (!t.isString())
+    {
+        // Re-form as a string token so we can compare to string
+        return token(keyword, t.lineNumber());
+    }
+    else
+    {
+        return t;
+    }
+}
+
+
+Foam::token Foam::functionEntries::ifeqEntry::expand
+(
+    const dictionary& dict,
+    const token& t
+)
+{
+    if (t.isWord())
+    {
+        return expand(dict, t.wordToken(), t);
+    }
+    else if (t.isVariable())
+    {
+        return expand(dict, t.stringToken(), t);
+    }
+    else if (t.isString())
+    {
+        return expand(dict, t.stringToken(), t);
+    }
+    else
+    {
+        return t;
+    }
+}
+
+
+bool Foam::functionEntries::ifeqEntry::equalToken
+(
+    const token& t1,
+    const token& t2
+)
+{
+    const bool eqType = (t1.type() == t2.type());
+
+    switch (t1.type())
+    {
+        case token::UNDEFINED:
+            return eqType;
+
+        case token::BOOL:
+            return (eqType && t1.boolToken() == t2.boolToken());
+
+        case token::FLAG:
+            return (eqType && t1.flagToken() == t2.flagToken());
+
+        case token::PUNCTUATION:
+            return (eqType && t1.pToken() == t2.pToken());
+
+        case token::WORD:
+            if (eqType)
+            {
+                return t1.wordToken() == t2.wordToken();
+            }
+            else if (t2.isString())
+            {
+                wordRe w2(t2.stringToken(), wordRe::DETECT);
+                return w2.match(t1.wordToken(), false);
+            }
+            else