|| || || || || || || ||

---

StringParser.h

Go to the documentation of this file.

#ifndef Impala_Util_StringParser_h
#define Impala_Util_StringParser_h

#include <string>
#include <iostream>
#include "Basis/String.h"
#include "Core/Geometry/Rectangle.h"

namespace Impala
{
namespace Util
{


class StringParser
{
public:

    StringParser(CString text, String::size_type startPoint = 0)
        : mText(text), mSize(text.size())
    {
        mP = Min<String::size_type>(startPoint, mSize);
    }

    int
    GetInt(char delim = ' ', bool delimRequired = false, bool eatDelim = false)
    {
        SkipWhitespace(delim);
        String::size_type end = mText.find(delim, mP);
        if ((end == String::npos) && delimRequired)
            std::cout << "StringParser::getInt: delim not found" << std::endl;
        String iStr = mText.substr(mP, end - mP);
        //std::cout << "iStr = " << iStr << std::endl;
        if (eatDelim)
        {
            mP = (end == String::npos) ? mSize : end+1;
        }
        else
        {
            mP = (end == String::npos) ? mSize : end;
        }
        return atoi(iStr);
    }

    double
    GetDouble(char delim = ' ', bool delimRequired = false,
              bool eatDelim = false)
    {
        SkipWhitespace(delim);
        String::size_type end = mText.find(delim, mP);
        if ((end == String::npos) && delimRequired)
            std::cout << "StringParser::getDouble: delim not found" <<std::endl;
        String fStr = mText.substr(mP, end - mP);
        //std::cout << "fStr = " << fStr << std::endl;
        if (eatDelim)
        {
            mP = (end == String::npos) ? mSize : end+1;
        }
        else
        {
            mP = (end == String::npos) ? mSize : end;
        }
        return atof(fStr);
    }

    String
    GetString(char delim = '"', bool delimRequired = true)
    {
        SkipWhitespace();
        if (mText[mP] == delim)
            mP++;
        String::size_type end = mText.find(delim, mP);
        if ((end == String::npos) && delimRequired)
            std::cout << "StringParser::getString: delim not found" <<std::endl;
        String str = mText.substr(mP, end - mP);
        //std::cout << "str = " << str << std::endl;
        mP = (end == String::npos) ? mSize : end+1; // skip delim
        return str;
    }

    String
    GetString2(bool delimRequired = true)
    {
        SkipWhitespace();
        if (Peek() == '"')
            return GetString('"', delimRequired);
        return GetString(' ', delimRequired);
    }

    Core::Geometry::Rectangle
    GetRectangle(char delim = '"', bool delimRequired = true)
    {
        SkipWhitespace(delim);
        int coord[4];
        char delims[4] = {' ', ' ', ' ', delim};
        for (int i=0 ; i<4 ; i++)
        {
            String::size_type end = mText.find(delims[i], mP);
            if ((end == String::npos) && delimRequired)
                std::cout << "StringParser::getRectangle: delim not found"
                          << std::endl;
            String str = mText.substr(mP, end - mP);
            //std::cout << "str = " << str << std::endl;
            coord[i] = atoi(str);
            mP = (end == String::npos) ? end : end+1;
        }
        return Core::Geometry::Rectangle(coord[0],coord[1],coord[2],coord[3]);
    }

    bool
    TheEnd() const
    {
        return ((mP == String::npos) || (mP >= mSize));
    }

    void
    Eat(char toChar, int nrToFind = 1)
    {
        while ((mP != String::npos) && (--nrToFind >= 0))
        {
            mP = mText.find(toChar, mP);
            if (mP != String::npos)
                mP++;
        }
    }

    void
    Eat(CString str, int nrToFind = 1)
    {
        while ((mP != String::npos) && (--nrToFind >= 0))
        {
            mP = mText.find(str, mP);
            if (mP != String::npos)
                mP += str.size();
        }
    }

    void
    Advance(char toChar, int nrToFind = 1)
    {
        while ((mP != String::npos) && (--nrToFind >= 0))
        {
            mP = mText.find(toChar, mP);
            if ((mP != String::npos) && (nrToFind >= 1))
                mP++; // skip it if looking for more
        }
    }

    void
    Advance(CString toStr, int nrToFind = 1)
    {
        while ((mP != String::npos) && (--nrToFind >= 0))
        {
            mP = mText.find(toStr, mP);
            if ((mP != String::npos) && (nrToFind >= 1))
                mP += toStr.size(); // skip it if looking for more
        }
    }

    void
    AdvanceP(int nrPos = 1)
    {
        if (mP == String::npos)
            return;
        mP += nrPos;
        if (mP >= mSize)
            mP = String::npos;
    }

    bool
    At(const String& s)
    {
        return mText.compare(mP, s.size(), s) == 0;
    }

    char
    Peek()
    {
        return mText[mP];
    }

    bool
    Contains(String subStr)
    {
        return (mText.find(subStr, mP) != String::npos);
    }

    // skips spaces and delim
    void
    SkipWhitespace(char delim = ' ')
    {
        while (mText[mP] == ' ')
            mP++;
        if (mText[mP] == delim)
            mP++;
    }

    String::size_type
    Position() const
    {
        return mP;
    }

private:

    const String            mText;
    const String::size_type mSize;
    String::size_type mP;

};

} // namespace Util
} // namespace Impala

#endif

---