Add the OpenFOAM source tree

src/OpenFOAM/primitives/strings/string/string.C

@@ -0,0 +1,178 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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 "string.H"
+#include "stringOps.H"
+
+
+/* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
+
+const char* const Foam::string::typeName = "string";
+int Foam::string::debug(Foam::debug::debugSwitch(string::typeName, 0));
+const Foam::string Foam::string::null;
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Count and return the number of a given character in the string
+Foam::string::size_type Foam::string::count(const char c) const
+{
+    register size_type cCount = 0;
+
+    for (const_iterator iter = begin(); iter != end(); ++iter)
+    {
+        if (*iter == c)
+        {
+            ++cCount;
+        }
+    }
+
+    return cCount;
+}
+
+
+// Replace first occurence of sub-string oldStr with newStr
+Foam::string& Foam::string::replace
+(
+    const string& oldStr,
+    const string& newStr,
+    size_type start
+)
+{
+    size_type newStart = start;
+
+    if ((newStart = find(oldStr, newStart)) != npos)
+    {
+        std::string::replace(newStart, oldStr.size(), newStr);
+    }
+
+    return *this;
+}
+
+
+// Replace all occurences of sub-string oldStr with newStr
+Foam::string& Foam::string::replaceAll
+(
+    const string& oldStr,
+    const string& newStr,
+    size_type start
+)
+{
+    if (oldStr.size())
+    {
+        size_type newStart = start;
+
+        while ((newStart = find(oldStr, newStart)) != npos)
+        {
+            std::string::replace(newStart, oldStr.size(), newStr);
+            newStart += newStr.size();
+        }
+    }
+
+    return *this;
+}
+
+
+Foam::string& Foam::string::expand(const bool allowEmpty)
+{
+    stringOps::inplaceExpand(*this, allowEmpty);
+    return *this;
+}
+
+
+// Remove repeated characters returning true if string changed
+bool Foam::string::removeRepeated(const char character)
+{
+    bool changed = false;
+
+    if (character && find(character) != npos)
+    {
+        register string::size_type nChar=0;
+        iterator iter2 = begin();
+
+        register char prev = 0;
+
+        for
+        (
+            string::const_iterator iter1 = iter2;
+            iter1 != end();
+            iter1++
+        )
+        {
+            register char c = *iter1;
+
+            if (prev == c && c == character)
+            {
+                changed = true;
+            }
+            else
+            {
+                *iter2 = prev = c;
+                ++iter2;
+                ++nChar;
+            }
+        }
+        resize(nChar);
+    }
+
+    return changed;
+}
+
+
+// Return string with repeated characters removed
+Foam::string Foam::string::removeRepeated(const char character) const
+{
+    string str(*this);
+    str.removeRepeated(character);
+    return str;
+}
+
+
+// Remove trailing character returning true if string changed
+bool Foam::string::removeTrailing(const char character)
+{
+    bool changed = false;
+
+    string::size_type nChar = size();
+    if (character && nChar > 1 && operator[](nChar-1) == character)
+    {
+        resize(nChar-1);
+        changed = true;
+    }
+
+    return changed;
+}
+
+
+// Return string with trailing character removed
+Foam::string Foam::string::removeTrailing(const char character) const
+{
+    string str(*this);
+    str.removeTrailing(character);
+    return str;
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/string/string.H

@@ -0,0 +1,236 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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::string
+
+Description
+    A class for handling character strings derived from std::string.
+
+    Strings may contain any characters and therefore are delimited by quotes
+    for IO : "any list of characters".
+
+    Used as a base class for word and fileName.
+
+See Also
+    Foam::findEtcFile() for information about the site/user OpenFOAM
+    configuration directory
+
+SourceFiles
+    string.C
+    stringIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef string_H
+#define string_H
+
+#include "char.H"
+#include "Hasher.H"
+
+#include <string>
+#include <cstring>
+#include <cstdlib>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+class string;
+Istream& operator>>(Istream&, string&);
+Ostream& operator<<(Ostream&, const string&);
+Ostream& operator<<(Ostream&, const std::string&);
+
+
+/*---------------------------------------------------------------------------*\
+                           Class string Declaration
+\*---------------------------------------------------------------------------*/
+
+class string
+:
+    public std::string
+{
+public:
+
+    // Static data members
+
+        static const char* const typeName;
+        static int debug;
+
+        //- An empty string
+        static const string null;
+
+
+    //- Hashing function class, shared by all the derived classes
+    class hash
+    {
+    public:
+        hash()
+        {}
+
+        inline unsigned operator()(const string&, unsigned seed = 0) const;
+    };
+
+
+    // Constructors
+
+        //- Construct null
+        inline string();
+
+        //- Construct from std::string
+        inline string(const std::string&);
+
+        //- Construct as copy of character array
+        inline string(const char*);
+
+        //- Construct as copy of specified number of characters
+        inline string(const char*, const size_type);
+
+        //- Construct from a single character
+        inline string(const char);
+
+        //- Construct from Istream
+        string(Istream&);
+
+
+    // Member Functions
+
+        //- Count and return the number of a given character in the string
+        size_type count(const char) const;
+
+        //- Is this string type valid?
+        template<class String>
+        static inline bool valid(const string&);
+
+        //- Does this string have particular meta-characters?
+        //  The meta characters can be optionally quoted.
+        template<class String>
+        static inline bool meta(const string&, const char quote='\\');
+
+        //- Strip invalid characters from the given string
+        template<class String>
+        static inline bool stripInvalid(string&);
+
+        //- Return a valid String from the given string
+        template<class String>
+        static inline String validate(const string&);
+
+        //- Return a String with quoted meta-characters from the given string
+        template<class String>
+        static inline string quotemeta(const string&, const char quote='\\');
+
+        //- True when strings match literally
+        inline bool match(const std::string&) const;
+
+        //- Avoid masking the normal std::string replace
+        using std::string::replace;
+
+        //- Replace first occurence of sub-string oldStr with newStr
+        //  starting at start
+        string& replace
+        (
+            const string& oldStr,
+            const string& newStr,
+            size_type start = 0
+        );
+
+        //- Replace all occurences of sub-string oldStr with newStr
+        //  starting at start
+        string& replaceAll
+        (
+            const string& oldStr,
+            const string& newStr,
+            size_type start = 0
+        );
+
+        //- Expand initial tildes and all occurences of environment variables
+        //  Expansion includes:
+        //  -# environment variables
+        //    - "$VAR", "${VAR}"
+        //  -# current directory
+        //    - leading "./" : the current directory
+        //  -# tilde expansion
+        //    - leading "~/" : home directory
+        //    - leading "~user" : home directory for specified user
+        //    - leading "~OpenFOAM" : site/user OpenFOAM configuration directory
+        //
+        //  Any unknown entries are removed silently if allowEmpty is true
+        //  \sa
+        //  Foam::findEtcFile
+        string& expand(const bool allowEmpty = false);
+
+        //- Remove repeated characters returning true if string changed
+        bool removeRepeated(const char);
+
+        //- Return string with repeated characters removed
+        string removeRepeated(const char) const;
+
+        //- Remove trailing character returning true if string changed
+        bool removeTrailing(const char);
+
+        //- Return string with trailing character removed
+        string removeTrailing(const char) const;
+
+
+    // Member Operators
+
+        //- Return the sub-string from the i-th character for \a n characters
+        inline string operator()
+        (
+            const size_type i,
+            const size_type n
+        ) const;
+
+        //- Return the sub-string from the first character for \a n characters
+        inline string operator()
+        (
+            const size_type n
+        ) const;
+
+
+    // IOstream Operators
+
+        friend Istream& operator>>(Istream&, string&);
+        friend Ostream& operator<<(Ostream&, const string&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "stringI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/string/stringI.H

@@ -0,0 +1,213 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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 <iostream>
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline Foam::string::string()
+{}
+
+
+inline Foam::string::string(const std::string& str)
+:
+    std::string(str)
+{}
+
+
+// Copy character array
+inline Foam::string::string(const char* str)
+:
+    std::string(str)
+{}
+
+
+// Construct from a given number of characters in a character array
+inline Foam::string::string(const char* str, const size_type len)
+:
+    std::string(str, len)
+{}
+
+
+// Construct from a single character
+inline Foam::string::string(const char c)
+:
+    std::string(1, c)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class String>
+inline bool Foam::string::valid(const string& str)
+{
+    for (const_iterator iter = str.begin(); iter != str.end(); ++iter)
+    {
+        if (!String::valid(*iter))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+
+template<class String>
+inline bool Foam::string::stripInvalid(string& str)
+{
+    if (!valid<String>(str))
+    {
+        register size_type nValid = 0;
+        iterator iter2 = str.begin();
+
+        for
+        (
+            const_iterator iter1 = iter2;
+            iter1 != const_cast<const string&>(str).end();
+            iter1++
+        )
+        {
+            register char c = *iter1;
+
+            if (String::valid(c))
+            {
+                *iter2 = c;
+                ++iter2;
+                ++nValid;
+            }
+        }
+
+        str.resize(nValid);
+
+        return true;
+    }
+
+    return false;
+}
+
+
+template<class String>
+inline bool Foam::string::meta(const string& str, const char quote)
+{
+    int escaped = 0;
+    for (const_iterator iter = str.begin(); iter != str.end(); ++iter)
+    {
+        if (quote && *iter == quote)
+        {
+            escaped ^= 1;  // toggle state
+        }
+        else if (escaped)
+        {
+            escaped = false;
+        }
+        else if (String::meta(*iter))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+template<class String>
+inline Foam::string
+Foam::string::quotemeta(const string& str, const char quote)
+{
+    if (!quote)
+    {
+        return str;
+    }
+
+    string sQuoted;
+    sQuoted.reserve(2*str.length());
+
+    int escaped = 0;
+    for (const_iterator iter = str.begin(); iter != str.end(); ++iter)
+    {
+        if (*iter == quote)
+        {
+            escaped ^= 1;  // toggle state
+        }
+        else if (escaped)
+        {
+            escaped = 0;
+        }
+        else if (String::meta(*iter))
+        {
+            sQuoted += quote;
+        }
+
+        sQuoted += *iter;
+    }
+
+    sQuoted.resize(sQuoted.length());
+
+    return sQuoted;
+}
+
+
+template<class String>
+inline String Foam::string::validate(const string& str)
+{
+    string ss = str;
+    stripInvalid<String>(ss);
+    return ss;
+}
+
+inline bool Foam::string::match(const std::string& str) const
+{
+    // check as string
+    return (str == *this);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+inline Foam::string Foam::string::operator()
+(
+    const size_type i,
+    const size_type n
+) const
+{
+    return substr(i, n);
+}
+
+
+inline Foam::string Foam::string::operator()(const size_type n) const
+{
+    return substr(0, n);
+}
+
+
+inline unsigned Foam::string::hash::operator()
+(
+    const string& key,
+    unsigned seed
+) const
+{
+    return Hasher(key.data(), key.size(), seed);
+}
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/string/stringIO.C

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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 "string.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::string::string(Istream& is)
+{
+    is >> *this;
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, string& s)
+{
+    token t(is);
+
+    if (!t.good())
+    {
+        is.setBad();
+        return is;
+    }
+
+    if (t.isString())
+    {
+        s = t.stringToken();
+    }
+    else
+    {
+        is.setBad();
+        FatalIOErrorIn("operator>>(Istream&, string&)", is)
+            << "wrong token type - expected string, found " << t.info()
+            << exit(FatalIOError);
+
+        return is;
+    }
+
+    // Check state of Istream
+    is.check("Istream& operator>>(Istream&, string&)");
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const string& s)
+{
+    os.write(s);
+    os.check("Ostream& operator<<(Ostream&, const string&)");
+    return os;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const std::string& s)
+{
+    os.write(string(s));
+    os.check("Ostream& operator<<(Ostream&, const std::string&)");
+    return os;
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/string/stringIOList.C

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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 "stringIOList.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineCompoundTypeName(List<string>, stringList);
+    addCompoundToRunTimeSelectionTable(List<string>, stringList);
+
+    defineTemplateTypeNameAndDebugWithName(stringIOList, "stringList", 0);
+    defineTemplateTypeNameAndDebugWithName
+    (
+        stringListIOList,
+        "stringListList",
+        0
+    );
+}
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/string/stringIOList.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::stringIOList
+
+Description
+    IO of a list of strings
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef stringIOList_H
+#define stringIOList_H
+
+#include "stringList.H"
+#include "IOList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOList<string> stringIOList;
+    typedef IOList<stringList> stringListIOList;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //