openFOAM代码阅读——基础代码中的string-卡核

代码仍然是src/OpenFOAM/primitives/路径中的，为文件夹strings，其中有内容

fileName keyType lists string stringOps word wordRe

这里的多个文件夹都使用到了这里的word文件夹中的文件，而word用到了string中的内容，所以我们先读这个吧。这里包含了如下几个文件：

string.C string.H stringI.H stringIO.C stringIOList.C stringIOList.H

从string.H开始读，正文太长了我们分段放出来读：

/*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
---------------------------------------------------------------------------*/
#include "char.H"
#include "Hasher.H"

#include <string>
#include <cstring>
#include <cstdlib>

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

这里使用到的char.H头文件前面已经度过了，就是给Foam名字域下的Istream和Ostream提供运算符重定义和readChar函数。Hasher.H头文件在路径~/OpenFOAM/OpenFOAM-7/src/OpenFOAM/primitives/hashes中，主要是代码实现了哈希的功能，我们之后会仔细阅读。

Description中描述了当前文件定义的类的功能，主要处理std::string的字符串。另外字符串因为可能包含多种符号，所以要用双引号

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&);

类似前面几个博客中阅读的，这里也是对>>和<<进行重定向，这里把多态扩展到了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();

        ...


    // Member Functions

        //- Count and return the number of a given character in the string
        size_type count(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;

        inline void operator=(const string&);
        inline void operator=(string&&);


    // IOstream Operators

        friend Istream& operator>>(Istream&, string&);
        friend Ostream& operator<<(Ostream&, const string&);
};


void writeEntry(Ostream& os, const char* value);
void writeEntry(Ostream& os, const string& value);


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#include "stringI.H"

这里的stringI.H来自相同文件夹，其实是上述文件中所有inline函数的具体实现，基本上都是通过直接调用std名字域中的string变量来。而其余函数的具体实现，在string.C中。（话说为啥不直接用std::string）。具体可以使用的成员函数如下：

valid(const string& str)   判断是否合法
meta(const string&, const char quote='\\\\')   判断string是否含有特定的字符串
stripInvalid(string& str)  裁掉不合法的部分
validate(const string&)   从给定string中给出一个合法的string
quotemeta(const string&, const char quote='\\\\')  返回带有特定字符串的字符串
replace(const string& oldStr,const string& newStr,size_type start = 0) 替换
replaceAll(const string& oldStr,const string& newStr,size_type start = 0)  全部替换
...

string()(const size_type i,const size_type n) 从第i个开始的n个字符
string()(const size_type n)  从头开始的n个字符
operator=(const string&);  赋值
operator=(string&&);         赋值
>> <<的重定义和之前一致

这里还用到了stringOps.H，位于strings/stringOps/文件夹中,之后再去阅读。

我们接下来看另外一组文件，首先从stringIOList.H开始，内容如下：

#include "stringList.H"
#include "IOList.H"

namespace Foam
{
    typedef IOList<string> stringIOList;
    typedef IOList<stringList> stringListIOList;
}

定义了两个类型stringIOList和stringListIOList，即分别以string和stringList类型生成的IOList。而IOList类型的声明在IOList.H中，路径src/OpenFOAM/db/IOobjects/IOList/IOList.H。

我们之后再去阅读stringIO.C，内容如下，我直接将函数的功能注释在代码中：

#include "string.H"
#include "IOstreams.H"

// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

Foam::string::string(Istream& is)
{
    is >> *this; //将is中读取的字符串，保存在当前string对象中
}


// * * * * * * * * * * * * * * * IOstream Functions  * * * * * * * * * * * * //
//注意这些普通函数，不是某个类的成员函数
void Foam::writeEntry(Ostream& os, const char* value)
{
    os << value; //将char数组输出
}


void Foam::writeEntry(Ostream& os, const string& value)
{
    os << value; //将string输出
}


// * * * * * * * * * * * * * * * 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();
        FatalIOErrorInFunction(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;
}

//string意义下的运算符重定义，类似之前对char进行的工作
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;
}

最后一个文件stringIOList.C这里正文似乎对几个函数进行了声明，但是并未给出实现，再后续阅读读到了会在这里补齐

{
    defineCompoundTypeName(List<string>, stringList);
    addCompoundToRunTimeSelectionTable(List<string>, stringList);

    defineTemplateTypeNameAndDebugWithName(stringIOList, "stringList", 0);
    defineTemplateTypeNameAndDebugWithName
    (
        stringListIOList,
        "stringListList",
        0
    );
}

呃，后面稍微改一下形式吧，贴代码讲解的形式，不如直接在代码上注释。之后会在总结完一个模块后，集中说明模块的作用

文章版权归作者所有，未经允许请勿转载。

THE END