Source/SDXTabBasedStreamReader.cpp

// STD
#include <sstream>

#include "SDXTabBasedStreamReader.h"
#include "SDXContentHandler.h"

using namespace std;
using namespace SDX;
using namespace SDX::Formats;

TabBasedStreamReader::TabBasedStreamReader(istream* iStream, ContentHandler* contentHandler) :
        StreamReader(iStream, contentHandler)
{

}

void TabBasedStreamReader::startProcessing(){
        m_inExtendedAttrList = false;
        m_curLevel = 0;
}

void TabBasedStreamReader::endProcessing(){
        for(int i = 0; i < m_curLevel; i++)
                m_contentHandler->endNode();
}

bool TabBasedStreamReader::processLine(string& line){
        line.erase(line.find_last_not_of(" \t\n\r") + 1); // Strip whitespace from end of string
        if(line.empty())
                return true;

        unsigned int nodeNameStartIndex = 0;
        unsigned int nodeNameEndIndex = 0;

        // Check for node starts/endings
        if(!m_inExtendedAttrList){
                int newLevel = line.find_first_not_of("\t") + 1;
                line.erase(0, line.find_first_not_of(" \t\n\r")); // Strip whitespace from beginning of string

                int levelDiff = newLevel - m_curLevel;
                if(levelDiff == 0 && m_curLevel != 0)
                        m_contentHandler->endNode();
                else if(levelDiff < 0){
                        for(int i = 0, absDiff = levelDiff * -1; i <= absDiff; i++)
                                m_contentHandler->endNode();
                } else if(levelDiff > 1){
                        m_error = "Cannot indent more than one level at a time";
                        return false;
                }
                m_curLevel = newLevel;

                if(line.at(0) == '"' || line.at(0) == '\''){
                        nodeNameStartIndex = 1;
                        nodeNameEndIndex = line.find_first_of(line.at(0), 1);
                        if(nodeNameEndIndex == string::npos)
                                return false;
                } else {
                        nodeNameEndIndex = line.find_first_of(" \t");
                        if(nodeNameEndIndex == string::npos)
                                nodeNameEndIndex = line.length();
                }

                m_contentHandler->startNode(line.substr(nodeNameStartIndex, nodeNameEndIndex - nodeNameStartIndex));
        }

        // Extract attribute list
        line.erase(0, nodeNameEndIndex); // Strip node name
        if(line.empty())
                return true;

        m_inExtendedAttrList = line.at(line.size() - 1) == '\\';
        if(m_inExtendedAttrList){
                line.erase(line.size() - 1); // Erase backslash
                line.erase(line.find_last_not_of(" \t\n\r") + 1); // Strip whitespace from end of string
        }

        return processAttrList(line);
}

bool TabBasedStreamReader::processAttrList(string& attrList){
        attrList.erase(0, attrList.find_first_not_of(" \t")); // Strip whitespace from beginning of string
        while(!attrList.empty()){

                string attrName, attrValue;
                bool extractionOk = false;

                // Extract attribute name
                attrName = extractFirstValue(attrList, " \t=", &extractionOk);
                if(!extractionOk)
                        return false;

                // Extract attribute value
                if(!attrList.empty() && attrList.at(0) == '='){
                        attrList.erase(0, 1);

                        attrValue = extractFirstValue(attrList, " \t", &extractionOk);
                        if(!extractionOk)
                                return false;
                } else {
                        attrValue = attrName;
                        attrName = "";
                }

                // Add attribute
                m_contentHandler->writeAttribute(attrName, attrValue);

                attrList.erase(0, attrList.find_first_not_of(" \t")); // Strip whitespace from beginning of string
        }

        return true;
}

string TabBasedStreamReader::extractFirstValue(std::string& str, const char* unqoutedValueDelimiters, bool *ok){
        string retVal;

        char firstChar = str.at(0);
        unsigned int valueEnd = 0;
        if(firstChar == '"' || firstChar == '\''){
                valueEnd = str.find_first_of(firstChar, 1);
                if(valueEnd == string::npos){
                        setError(string("Unterminated ") + firstChar);

                        if(ok)
                                *ok = false;
                        return "";
                }

                retVal = str.substr(1, valueEnd++ - 1);
        } else {
                valueEnd = str.find_first_of(unqoutedValueDelimiters);
                if(valueEnd == string::npos)
                        retVal = str.substr(0, valueEnd - 2);
                else
                        retVal = str.substr(0, valueEnd);
        }
        str.erase(0, valueEnd);

        if(ok)
                *ok = true;
        return retVal;
}

---