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

applications/test/stringSplit/Test-stringSplit.C

@@ -35,11 +35,10 @@ Description
 
 using namespace Foam;
 
+// Simple utility
 template<class String>
-void printSplitting(const String& str, const char delimiter)
+void printSubStrings(const String& str, const SubStrings<String>& split)
 {
-    auto split = stringOps::split(str, delimiter);
-
     Info<< "string {" << str.size() << " chars} = " << str << nl
         << split.size() << " elements {" << split.length() << " chars}"
         << nl;
@@ -60,7 +59,28 @@ int main(int argc, char *argv[])
 {
     argList::noBanner();
     argList::noParallel();
-
+    argList::addOption
+    (
+        "any",
+        "delimChars",
+        "test split on any delimiter characters"
+    );
+    argList::addOption
+    (
+        "sub",
+        "string",
+        "test split on substring"
+    );
+    argList::addBoolOption
+    (
+        "slash",
+        "test split on slash (default)"
+    );
+    argList::addBoolOption
+    (
+        "space",
+        "test split on space"
+    );
     argList args(argc, argv, false, true);
 
     if (args.size() <= 1 && args.options().empty())
@@ -68,12 +88,83 @@ int main(int argc, char *argv[])
         args.printUsage();
     }
 
-    for (label argi=1; argi < args.size(); ++argi)
+    int nopts = 0;
+    for (auto optName : { "any", "slash", "space", "sub" })
     {
-        printSplitting(args[argi], '/');
+        if (args.optionFound(optName))
+        {
+            ++nopts;
+        }
+    }
+
+    if (args.optionFound("any"))
+    {
+        const std::string& str = args["any"];
+        Info<< "split on any chars" << nl
+            << "=" << str << nl
+            << "~~~~~~~~~~~~~~~" << nl;
+
+        for (label argi=1; argi < args.size(); ++argi)
+        {
+            const auto split = stringOps::splitAny(args[argi], str);
+            printSubStrings(args[argi], split);
+        }
+
+        if (nopts == 1)
+        {
+            return 0;
+        }
+    }
+
+    if (args.optionFound("sub"))
+    {
+        const std::string& str = args["sub"];
+        Info<< "split on substring" << nl
+            << "=" << str << nl
+            << "~~~~~~~~~~~~~~~" << nl;
+
+        for (label argi=1; argi < args.size(); ++argi)
+        {
+            const auto split = stringOps::split(args[argi], str);
+            printSubStrings(args[argi], split);
+        }
+
+        if (nopts == 1)
+        {
+            return 0;
+        }
+    }
+
+    if (args.optionFound("space"))
+    {
+        Info<< "split on space" << nl
+            << "~~~~~~~~~~~~~~" << nl;
+
+        for (label argi=1; argi < args.size(); ++argi)
+        {
+            const auto split = stringOps::splitSpace(args[argi]);
+            printSubStrings(args[argi], split);
+        }
+
+        if (nopts == 1)
+        {
+            return 0;
+        }
+    }
+
+    // Default
+    if (!nopts || args.optionFound("slash"))
+    {
+        Info<< "split on slash" << nl
+            << "~~~~~~~~~~~~~~" << nl;
+
+        for (label argi=1; argi < args.size(); ++argi)
+        {
+            const auto split = stringOps::split(args[argi], '/');
+            printSubStrings(args[argi], split);
+        }
     }
 
-    Info<< "\nEnd\n" << endl;
     return 0;
 }
 

doc/Doxygen/Doxyfile

@@ -51,7 +51,7 @@ PROJECT_BRIEF          = "The open source CFD toolbox"
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.
 
-PROJECT_LOGO           = OpenFOAM-logo2-55x55.png
+PROJECT_LOGO           = OpenFOAMlogo.png
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is

src/OpenFOAM/containers/Lists/List/List.C

@@ -231,12 +231,10 @@ Foam::List<T>::List(const PtrList<T>& lst)
 }
 
 
-// Note: using first/last is not entirely accurate.
-// But since the list size is correct, last() is actually ignored.
 template<class T>
 Foam::List<T>::List(const SLList<T>& lst)
 :
-    List<T>(lst.first(), lst.last(), lst.size())
+    List<T>(lst.begin(), lst.end(), lst.size())
 {}
 
 

src/OpenFOAM/primitives/strings/stringOps/stringOps.H

@@ -304,15 +304,44 @@ namespace stringOps
     Foam::word name(const std::string& fmt, const PrimitiveType& val);
 
 
-    //- Split a string into sub-strings at the delimiter character.
-    //  An empty sub-strings are suppressed.
+    //- Split string into sub-strings at the delimiter character.
+    //  Empty sub-strings are suppressed.
     template<class StringType>
     Foam::SubStrings<StringType> split
     (
         const StringType& str,
-        const char delimiter
+        const char delim
     );
 
+    //- Split string into sub-strings using delimiter string.
+    //  Empty sub-strings are suppressed.
+    template<class StringType>
+    Foam::SubStrings<StringType> split
+    (
+        const StringType& str,
+        const std::string& delim
+    );
+
+
+    //- Split string into sub-strings using any characters in delimiter.
+    //  Empty sub-strings are suppressed.
+    template<class StringType>
+    Foam::SubStrings<StringType> splitAny
+    (
+        const StringType& str,
+        const std::string& delim
+    );
+
+
+    //- Split string into sub-strings at whitespace (TAB, NL, VT, FF, CR, SPC)
+    //  Empty sub-strings are suppressed.
+    template<class StringType>
+    Foam::SubStrings<StringType> splitSpace
+    (
+        const StringType& str
+    );
+
+
 } // End namespace stringOps
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/primitives/strings/stringOps/stringOpsTemplates.C

@@ -69,7 +69,7 @@ template<class StringType>
 Foam::SubStrings<StringType> Foam::stringOps::split
 (
     const StringType& str,
-    const char delimiter
+    const char delim
 )
 {
     Foam::SubStrings<StringType> lst;
@@ -77,7 +77,7 @@ Foam::SubStrings<StringType> Foam::stringOps::split
 
     std::string::size_type beg = 0, end = 0;
 
-    while ((end = str.find(delimiter, beg)) != std::string::npos)
+    while ((end = str.find(delim, beg)) != std::string::npos)
     {
         if (beg < end)
         {
@@ -97,4 +97,84 @@ Foam::SubStrings<StringType> Foam::stringOps::split
 }
 
 
+template<class StringType>
+Foam::SubStrings<StringType> Foam::stringOps::split
+(
+    const StringType& str,
+    const std::string& delim
+)
+{
+    Foam::SubStrings<StringType> lst;
+    lst.reserve(20);
+
+    std::string::size_type beg = 0, end = 0;
+
+    while ((end = str.find(delim, beg)) != std::string::npos)
+    {
+        if (beg < end)
+        {
+            // (Non-empty) intermediate element
+            lst.append(str.cbegin() + beg, str.cbegin() + end);
+        }
+        beg = end + delim.size();
+    }
+
+    // (Non-empty) trailing element
+    if (beg < str.size())
+    {
+        lst.append(str.cbegin() + beg, str.cbegin() + str.size());
+    }
+
+    return lst;
+}
+
+
+template<class StringType>
+Foam::SubStrings<StringType> Foam::stringOps::splitAny
+(
+    const StringType& str,
+    const std::string& delim
+)
+{
+    Foam::SubStrings<StringType> lst;
+    lst.reserve(20);
+
+    std::string::size_type beg = 0;
+
+    while
+    (
+        (beg = str.find_first_not_of(delim, beg))
+     != std::string::npos
+    )
+    {
+        const auto end = str.find_first_of(delim, beg);
+
+        if (end == std::string::npos)
+        {
+            // Trailing element
+            lst.append(str.cbegin() + beg, str.cbegin() + str.size());
+            break;
+        }
+        else
+        {
+            // Intermediate element
+            lst.append(str.cbegin() + beg, str.cbegin() + end);
+            beg = end + 1;
+        }
+    }
+
+    return lst;
+}
+
+
+template<class StringType>
+Foam::SubStrings<StringType> Foam::stringOps::splitSpace
+(
+    const StringType& str
+)
+{
+    return splitAny(str, "\t\n\v\f\r ");
+}
+
+
 // ************************************************************************* //

src/functionObjects/doc/functionObjects.dox

@@ -0,0 +1,97 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2014 OpenFOAM Foundation
+     \\/     M anipulation  | Copyright (C) 2015-2017 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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/>.
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+\page pagePostProcessing Post-processing
+
+\section secFunctionObjects Function objects
+
+OpenFOAM includes a collection of \ref grpFunctionObjects that offer users the
+opportunity to closely manage their computational analyses.  These objects can
+be applied to manipulate the workflow process, and provide a mechanism to
+extract predicted field and derived quantities at run-time.  Alternatively,
+the actions can be executed afterwards using the \c execFlowFunctionObjects
+utility.
+
+\linebreak
+The current range of features comprises of:
+- \ref grpFieldFunctionObjects
+- \ref grpForcesFunctionObjects
+- \ref grpGraphicsFunctionObjects
+- \ref grpLagrangianFunctionObjects
+- \ref grpSolversFunctionObjects
+- \ref grpUtilitiesFunctionObjects
+
+\linebreak
+\subsection secFieldFunctionObjectUsage Using function objects
+
+Function objects are defined by additional entries in the
+$FOAM_CASE/system/controlDict input dictionary.  Each object is listed in a
+\c functions sub-dictionary entry, e.g. the following shows the input options
+applicable to `output' -type objects:
+
+\verbatim
+functions
+{
+    myFunctionObject    // user-defined name of function object entry
+    {
+        type                functionObjectType;
+        libs                ("libMyFunctionObjectlib.so");
+        region              defaultRegion;
+        enabled             yes;
+        timeStart           0;
+        timeEnd             10;
+        evaluateControl     timeStep;
+        evaluateInterval    1;
+        writeControl        outputTime;
+        writeInterval       1;
+        ...
+    }
+}
+\endverbatim
+
+Where:
+\table
+    Property | Description                           | Required | Default value
+    type     | type of function object               | yes      |
+    libs     | libraries containing object implementation | yes |
+    region   | name of region for multi-region cases | no       |
+    enabled  | on/off switch                         | no       | yes
+    timeStart| start time                            | no       |
+    timeEnd  | end time                              | no       |
+    evaluateControl | when to evaluate: either 'writeTime' or 'timeStep'| no | timeStep
+    evaluateInterval| steps between evaluation when evaluateControl=timeStep | no | 1
+    writeControl | when to output: either 'writeTime' or 'timeStep'| no | timeStep
+    writeInterval| steps between output when writeControl=timeStep | no | 1
+\endtable
+
+The sub-dictionary name \c myFunctionObject is chosen by the user, and is
+typically used as the name of the output directory for any derived data.  The
+\c type entry defines the type of function object properties that follow.
+Since the function objects are packaged into separate libraries, the user must
+tell the code where to find the function object implementation, identified
+using the \c functionObjectLibs entry.
+
+
+\*---------------------------------------------------------------------------*/