BOL::AsciiXmlParser Class Reference

#include <AsciiXmlParser.hpp>

Detailed Description

Definition at line 29 of file AsciiXmlParser.hpp.

Public Member Functions
	AsciiXmlParser (bool const isVerbose=false)
void	closeFile ()
bool	currentElementNameMatches (std::string const &comparisonString) const
std::map< std::string, std::string > const &	getCurrentElementAttributes ()
std::string const &	getCurrentElementContent () const
std::string const &	getCurrentElementName () const
std::string const &	getCurrentOpeningTagAsFound () const
std::pair< int, int > const &	getLineRangeOfCurrentElement () const
std::string	getTrimmedCurrentElementContent () const
bool	loadString (std::string const stringToParse)
bool	openRootElementOfFile (std::string const &fileName)
bool	readAllOfRootElementOfFile (std::string const &fileName)
bool	readNextElement ()
void	returnToBeginningOfText ()
	~AsciiXmlParser ()

Protected Member Functions
bool	closeMarkup (size_t const startPosition=0)
bool	compareMarkupEnd (std::string const &comparisonString) const
bool	compareMarkupStart (std::string const &comparisonString) const
bool	discardToNextMarkup ()
bool	discardToNextTag ()
bool	eraseQuotedStringsInMarkup (size_t const startPosition)
bool	ignoreDelimited (std::pair< std::string, std::string > const &delimitingStrings)
bool	parseAttributes ()
bool	parseTagName (std::string &nameDestination)
bool	readCharacter ()
bool	recordDelimited (std::pair< std::string, std::string > const &delimitingStrings)
void	recordTagTo (std::string &recordingString)
bool	recordTo (std::string &recordingString, char const endChar)
bool	recordToEndOfElement ()
bool	recordToNextMarkup ()
bool	recordToNextTag ()
void	resetContent ()
bool	skipPrologAndOpenRootElement ()

Protected Attributes
std::string	closingTag
int	closingTagsToFind
std::pair< std::string, std::string >	currentAttribute
char	currentChar
char	currentQuoteChar
std::string	currentTagName
std::map< std::string, std::string >	elementAttributeMap
std::pair< int, int >	elementLineRange
std::string	elementName
std::ifstream	fileParsingStream
std::string	fullElementContentAsFound
std::string	fullOpeningTagAsFound
bool const	isVerbose
std::string	markupString
int	newlinesBeforeMarkup
size_t	parseEnd
size_t	parseStart
size_t	previousLength
int	readNewlines
std::map< std::string, std::string >	rootAttributeMap
std::pair< int, int >	rootLineRange
std::string	rootTag
bool	streamIsGood
std::istringstream	stringParsingStream
std::istream *	textStream

Static Protected Attributes
static std::string const	allowedXmlQuoteChars
static std::string const	allowedXmlWhitespaceChars
static std::pair< std::string, std::string > const	cdataDelimiter
static std::pair< std::string, std::string > const	commentDelimiter
static std::pair< std::string, std::string > const	doctypeDelimiter
static char const	markupCloser
static char const	markupOpener
static std::pair< std::string, std::string > const	piDelimiter
static char const	tagCloser

Constructor & Destructor Documentation

AsciiXmlParser()

BOL::AsciiXmlParser::AsciiXmlParser

(

bool const

isVerbose = false

)

Definition at line 36 of file AsciiXmlParser.cpp.

                                                       :
      isVerbose( isVerbose ),
      fileParsingStream(),
      stringParsingStream(),
      textStream( &stringParsingStream ),
      rootTag( "" ),
      rootAttributeMap(),
      rootLineRange( -1,
                     -1 ),
      elementName( "" ),
      fullElementContentAsFound( "" ),
      fullOpeningTagAsFound( "" ),
      elementAttributeMap(),
      elementLineRange( -1,
                        -1 ),
      markupString( "" ),
      streamIsGood( false ),
      currentChar( ' ' ),
      readNewlines( 0 ),
      newlinesBeforeMarkup( 0 ),
      parseStart( 0 ),
      parseEnd( 0 ),
      previousLength( 0 ),
      currentQuoteChar( '\'' ),
      currentAttribute( "",
                        "" ),
      closingTag( "" ),
      closingTagsToFind( 0 ),
      currentTagName( "" )
  {
    // just an initialization list.
  }

~AsciiXmlParser()

BOL::AsciiXmlParser::~AsciiXmlParser

(

)

Definition at line 69 of file AsciiXmlParser.cpp.

  {
    if( fileParsingStream.is_open() )
    {
      fileParsingStream.close();
    }
  }

Member Function Documentation

closeFile()

void BOL::AsciiXmlParser::closeFile ( )

inline

Definition at line 287 of file AsciiXmlParser.hpp.

  {
    if( fileParsingStream.is_open() )
    {
      fileParsingStream.close();
    }
    fileParsingStream.clear();
    textStream = &stringParsingStream;
  }

closeMarkup()

bool BOL::AsciiXmlParser::closeMarkup ( size_t const  startPosition = 0 )

protected

Definition at line 116 of file AsciiXmlParser.cpp.

  {
    streamIsGood = ( recordTo( markupString,
                               markupCloser )
                     &&
                     ignoreDelimited( commentDelimiter ) );
    if( !streamIsGood )
    {
      if( isVerbose )
      {
        std::cout
        << std::endl
        << "BOL::error! AsciiXmlParser::closeMarkup( " << startPosition
        << " ) could not find the end of a markup!";
        std::cout << std::endl;
      }
      return false;
    }
    parseStart = markupString.find_first_of( allowedXmlQuoteChars,
                                             startPosition );
    while( std::string::npos != parseStart )
    {
      currentQuoteChar = markupString[ parseStart ];
      parseEnd = markupString.find( currentQuoteChar,
                                    ( parseStart + 1 ) );
      while( std::string::npos == parseEnd )
      {
        markupString.append( 1,
                             markupCloser );
        previousLength = markupString.size();
        streamIsGood = recordTo( markupString,
                                 markupCloser );
        if( !streamIsGood )
        {
          if( isVerbose )
          {
            std::cout
            << std::endl
            << "BOL::error! AsciiXmlParser::closeMarkup( " << startPosition
            << ") could not find the end of a markup!";
            std::cout << std::endl;
          }
          return false;
        }
        parseEnd = markupString.find( currentQuoteChar,
                                      previousLength );
      }
      parseStart = markupString.find_first_of( allowedXmlQuoteChars,
                                               ( parseEnd + 1 ) );
    }
    return true;
  }

compareMarkupEnd()

bool BOL::AsciiXmlParser::compareMarkupEnd ( std::string const &  comparisonString ) const

inlineprotected

Definition at line 521 of file AsciiXmlParser.hpp.

  {
    return ( 0 == comparisonString.compare( 0,
                                            ( comparisonString.size() - 1 ),
                                            markupString,
                        ( markupString.size() - comparisonString.size() + 1 ),
                                           ( comparisonString.size() - 1 ) ) );
  }

compareMarkupStart()

bool BOL::AsciiXmlParser::compareMarkupStart ( std::string const &  comparisonString ) const

inlineprotected

Definition at line 508 of file AsciiXmlParser.hpp.

  {
    return ( 0 == comparisonString.compare( 1,
                                            ( comparisonString.size() - 1 ),
                                            markupString,
                                            0,
                                           ( comparisonString.size() - 1 ) ) );
  }

currentElementNameMatches()

bool BOL::AsciiXmlParser::currentElementNameMatches ( std::string const &  comparisonString ) const

inline

Definition at line 331 of file AsciiXmlParser.hpp.

  {
    return ( 0 == elementName.compare( comparisonString ) );
  }

discardToNextMarkup()

bool BOL::AsciiXmlParser::discardToNextMarkup ( )

inlineprotected

Definition at line 429 of file AsciiXmlParser.hpp.

  {
    while( readCharacter()
           &&
           ( markupOpener != currentChar ) )
    {
      // the conditional does the work of reading up to the next tag.
    }
    newlinesBeforeMarkup = readNewlines;
    return ( streamIsGood
             &&
             closeMarkup() );
  }

discardToNextTag()

bool BOL::AsciiXmlParser::discardToNextTag ( )

inlineprotected

Definition at line 449 of file AsciiXmlParser.hpp.

  {
    markupString.assign( "" );
    while( markupString.empty() )
    {
      streamIsGood = ( discardToNextMarkup()
                       &&
                       ignoreDelimited( commentDelimiter )
                       &&
                       ignoreDelimited( piDelimiter )
                       &&
                       ignoreDelimited( cdataDelimiter ) );
      if( !streamIsGood )
      {
        return false;
      }
    }
    return true;
  }

eraseQuotedStringsInMarkup()

bool BOL::AsciiXmlParser::eraseQuotedStringsInMarkup ( size_t const  startPosition )

protected

Definition at line 260 of file AsciiXmlParser.cpp.

  {
    // at this point, every opening quote in markupString from startPosition is
    // matched by a closing quote (properly nested).
    parseStart = markupString.find_first_of( allowedXmlQuoteChars,
                                             startPosition );
    while( std::string::npos != parseStart )
    {
      currentQuoteChar = markupString[ parseStart ];
      parseEnd = markupString.find( currentQuoteChar,
                                    ( parseStart + 1 ) );
      markupString.erase( parseStart,
                          ( parseEnd - parseStart + 1 ) );
      // we have to erase the closing quote character as well.
      parseStart = markupString.find_first_of( allowedXmlQuoteChars,
                                               parseStart );
    }
    // at this point, all quoted strings have been removed from markupString,
    // & now it ends at the 1st unquoted '>' in the text.
    return true;
  }

getCurrentElementAttributes()

std::map< std::string, std::string > const & BOL::AsciiXmlParser::getCurrentElementAttributes ( )

inline

Definition at line 357 of file AsciiXmlParser.hpp.

  {
    return elementAttributeMap;
  }

getCurrentElementContent()

std::string const & BOL::AsciiXmlParser::getCurrentElementContent ( ) const

inline

Definition at line 338 of file AsciiXmlParser.hpp.

  {
    return fullElementContentAsFound;
  }

getCurrentElementName()

std::string const & BOL::AsciiXmlParser::getCurrentElementName ( ) const

inline

Definition at line 325 of file AsciiXmlParser.hpp.

  {
    return elementName;
  }

getCurrentOpeningTagAsFound()

std::string const & BOL::AsciiXmlParser::getCurrentOpeningTagAsFound ( ) const

inline

Definition at line 351 of file AsciiXmlParser.hpp.

  {
    return fullOpeningTagAsFound;
  }

getLineRangeOfCurrentElement()

std::pair< int, int > const & BOL::AsciiXmlParser::getLineRangeOfCurrentElement ( ) const

inline

Definition at line 363 of file AsciiXmlParser.hpp.

  {
    return elementLineRange;
  }

getTrimmedCurrentElementContent()

std::string BOL::AsciiXmlParser::getTrimmedCurrentElementContent ( ) const

inline

Definition at line 344 of file AsciiXmlParser.hpp.

  {
    return StringParser::trimFromFrontAndBack( fullElementContentAsFound,
                                               allowedXmlWhitespaceChars );
  }

ignoreDelimited()

bool BOL::AsciiXmlParser::ignoreDelimited ( std::pair< std::string, std::string > const &  delimitingStrings )

protected

Definition at line 178 of file AsciiXmlParser.cpp.

  {
    if( !(compareMarkupStart( delimitingStrings.first )) )
    {
      return true;
    }
    while( !(compareMarkupEnd( delimitingStrings.second )) )
    {
      streamIsGood = recordTo( markupString,
                               markupCloser );
      if( !streamIsGood )
      {
        if( isVerbose )
        {
          std::cout
          << std::endl
          << "BOL::error! AsciiXmlParser::ignoreDelimited( \""
          << delimitingStrings.first << ", " << delimitingStrings.second
          << "\" ) could not find the ending delimiter!";
          std::cout << std::endl;
        }
        return false;
      }
    }
    markupString.assign( "" );
    return true;
  }

loadString()

bool BOL::AsciiXmlParser::loadString ( std::string const  stringToParse )

inline

Definition at line 273 of file AsciiXmlParser.hpp.

  {
    resetContent();
    stringParsingStream.clear();
    stringParsingStream.str( stringToParse );
    textStream = &stringParsingStream;
    return stringParsingStream.good();
  }

openRootElementOfFile()

bool BOL::AsciiXmlParser::openRootElementOfFile

(

std::string const &

fileName

)

Definition at line 79 of file AsciiXmlParser.cpp.

  {
    closeFile();
    fileParsingStream.open( fileName.c_str() );
    if( !(fileParsingStream.good()) )
    {
      if( isVerbose )
      {
        std::cout
        << std::endl
        << "BOL::error! AsciiXmlParser::openRootElementOfFile( " << fileName
        << " ) could not open the file!";
        std::cout << std::endl;
      }
      return false;
    }
    textStream = &fileParsingStream;
    streamIsGood = skipPrologAndOpenRootElement();
    if( !streamIsGood
        &&
        isVerbose )
    {
      std::cout
      << std::endl
      << "BOL::error! AsciiXmlParser::openRootElementOfFile( " << fileName
      << " ) could not find a root element!";
      std::cout << std::endl;
    }
    return streamIsGood;
  }

parseAttributes()

bool BOL::AsciiXmlParser::parseAttributes ( )

protected

Definition at line 287 of file AsciiXmlParser.cpp.

  {
    elementAttributeMap.clear();
    parseStart = markupString.find_first_not_of( allowedXmlWhitespaceChars,
                                                 parseEnd );
    while( std::string::npos != parseStart )
    {
      if( ( ( markupString.size() - 1 ) == parseStart )
          &&
          ( tagCloser == markupString[ parseStart ] ) )
      {
        // if there is only whitespace left in the markup or the indicator of
        // an empty element, the parsing is done:
        return true;
      }
      // at this point, we have found a new attribute.
      parseEnd = markupString.find( '=',
                                    parseStart );
      if( std::string::npos == parseEnd )
      {
        if( isVerbose )
        {
          std::cout
          << std::endl
          << "BOL::error! AsciiXmlParser::parseOpeningTag() found an attribute"
          << " (\"" << markupString.substr( parseStart )
          << "\") without a value!";
          std::cout << std::endl;
        }
        return false;
      }
      currentAttribute.first.assign( markupString.substr( parseStart,
                                                 ( parseEnd - parseStart ) ) );
      currentQuoteChar = markupString[ ( ++parseEnd ) ];
      // this really should be ' or " for valid XML, but we won't bother
      // checking...
      parseStart = ( ++parseEnd );
      // the attribute's value begins after the '=' & the quote character (by
      // this point, parseEnd has been incremented twice before parseStart gets
      // set).
      parseEnd = markupString.find( currentQuoteChar,
                                    parseStart );
      if( std::string::npos == parseEnd )
        // this shouldn't ever happen, because such cases should have already
        // been caught by closeMarkup().
      {
        if( isVerbose )
        {
          std::cout
          << std::endl
          << "BOL::error! AsciiXmlParser::parseOpeningTag() found an attribute"
          << " (\"" << markupString.substr( parseStart )
          << "\") without a well-formed value (no closing quote mark)!";
          std::cout << std::endl;
        }
        return false;
      }
      currentAttribute.second.assign( markupString.substr( parseStart,
                                                 ( parseEnd - parseStart ) ) );
      elementAttributeMap.insert( currentAttribute );
      parseStart = markupString.find_first_not_of( allowedXmlWhitespaceChars,
                                                   ( ++parseEnd ) );
      // parseEnd has to be incremented so that parseStart doesn't just sit on
      // the closing quote.
    }
    return true;
  }

parseTagName()

bool BOL::AsciiXmlParser::parseTagName ( std::string &  nameDestination )

inlineprotected

Definition at line 545 of file AsciiXmlParser.hpp.

  {
    parseStart = markupString.find_first_not_of( allowedXmlWhitespaceChars );
    if( std::string::npos == parseStart )
    {
      // empty markup is a sign of malformed XML:
      if( isVerbose )
      {
        std::cout
        << std::endl
        << "BOL::error! AsciiXmlParser::parseOpeningTag(...) found empty"
        << " markup!";
        std::cout << std::endl;
      }
      return false;
    }
    parseEnd = markupString.find_first_of( allowedXmlWhitespaceChars,
                                           parseStart );
    nameDestination.assign( markupString.substr( parseStart,
                                                 ( parseEnd - parseStart ) ) );
    return true;
  }

readAllOfRootElementOfFile()

bool BOL::AsciiXmlParser::readAllOfRootElementOfFile ( std::string const &  fileName )

inline

Definition at line 248 of file AsciiXmlParser.hpp.

  {
    streamIsGood = ( openRootElementOfFile( fileName )
                     &&
                     recordToEndOfElement() );
    if( !streamIsGood
        &&
        isVerbose )
    {
      std::cout
      << std::endl
      << "BOL::error! AsciiXmlParser::readAllOfRootElementOfFile( " << fileName
      << " ) could not find a well-formed root element!";
      std::cout << std::endl;
    }
    rootLineRange.second = readNewlines;
    return streamIsGood;
  }

readCharacter()

bool BOL::AsciiXmlParser::readCharacter ( )

inlineprotected

Definition at line 394 of file AsciiXmlParser.hpp.

  {
    streamIsGood = textStream->get( currentChar ).good();
    if( streamIsGood
        &&
        ( '\n' == currentChar ) )
    {
      ++readNewlines;
    }
    return streamIsGood;
  }

readNextElement()

bool BOL::AsciiXmlParser::readNextElement ( )

inline

Definition at line 309 of file AsciiXmlParser.hpp.

  {
    return ( discardToNextTag()
             &&
             parseTagName( elementName )
             &&
             parseAttributes()
             &&
             recordToEndOfElement() );
  }

recordDelimited()

bool BOL::AsciiXmlParser::recordDelimited ( std::pair< std::string, std::string > const &  delimitingStrings )

protected

Definition at line 214 of file AsciiXmlParser.cpp.

  {
    if( !(compareMarkupStart( delimitingStrings.first )) )
    {
      return true;
    }
    while( !(compareMarkupEnd( delimitingStrings.second )) )
    {
      markupString.append( 1,
                           markupCloser );
      streamIsGood = recordTo( markupString,
                               markupCloser );
      if( !streamIsGood )
      {
        if( isVerbose )
        {
          std::cout
          << std::endl
          << "BOL::error! AsciiXmlParser::ignoreDelimited( \""
          << delimitingStrings.first << ", " << delimitingStrings.second
          << "\" ) could not find the ending delimiter!";
          std::cout << std::endl;
        }
        return false;
      }
    }
    fullElementContentAsFound.append( 1,
                                      markupOpener );
    fullElementContentAsFound.append( markupString );
    fullElementContentAsFound.append( 1,
                                      markupCloser );
    markupString.assign( "" );
    return true;
  }

recordTagTo()

void BOL::AsciiXmlParser::recordTagTo ( std::string &  recordingString )

inlineprotected

Definition at line 533 of file AsciiXmlParser.hpp.

  {
    recordingString.append( 1,
                            markupOpener );
    recordingString.append( markupString );
    recordingString.append( 1,
                            markupCloser );
  }

recordTo()

bool BOL::AsciiXmlParser::recordTo ( std::string &  recordingString, char const  endChar  )

inlineprotected

Definition at line 411 of file AsciiXmlParser.hpp.

  {
    while( readCharacter()
           &&
           endChar != currentChar )
    {
      recordingString.append( 1,
                              currentChar );
    }
    return streamIsGood;
  }

recordToEndOfElement()

bool BOL::AsciiXmlParser::recordToEndOfElement ( )

protected

Definition at line 360 of file AsciiXmlParser.cpp.

  {
    fullOpeningTagAsFound.assign( "" );
    recordTagTo( fullOpeningTagAsFound );
    fullElementContentAsFound.assign( "" );
    // we note which line the opening tag is on:
    elementLineRange.first = ( readNewlines + 1 );
    if( tagCloser == markupString[ markupString.size() - 1 ] )
    {
      // empty tags need no recording:
      elementLineRange.second = ( readNewlines + 1 );
      return true;
    }
    closingTag.assign( 1,
                       tagCloser );
    closingTag.append( elementName );
    closingTagsToFind = 1;
    // there could be nested elements of the same name (not necessarily nested
    // directly).
    while( 0 < closingTagsToFind )
    {
      streamIsGood = ( recordToNextTag()
                       &&
                       parseTagName( currentTagName ) );
      if( !streamIsGood )
      {
        return false;
      }
      if( 0 == currentTagName.compare( elementName ) )
      {
        // if a nested child element of the same name is found, the child
        // element is recorded too.
        ++closingTagsToFind;
      }
      else if( 0 == currentTagName.compare( closingTag ) )
      {
        --closingTagsToFind;
      }
      if( 0 < closingTagsToFind )
      {
        // if unless this is the closing tag of element, the markup must be
        // recorded, & here, because textStream has already gone past it.
        recordTagTo( fullElementContentAsFound );
      }
      else
      {
        // if this is the closing tag, we note which line it is on:
        elementLineRange.second = ( readNewlines + 1 );
      }
    }
    return true;
  }

recordToNextMarkup()

bool BOL::AsciiXmlParser::recordToNextMarkup ( )

inlineprotected

Definition at line 472 of file AsciiXmlParser.hpp.

  {
    return ( recordTo( fullElementContentAsFound,
                       markupOpener )
             &&
             closeMarkup() );
  }

recordToNextTag()

bool BOL::AsciiXmlParser::recordToNextTag ( )

inlineprotected

Definition at line 485 of file AsciiXmlParser.hpp.

  {
    markupString.assign( "" );
    while( markupString.empty() )
    {
      streamIsGood = ( recordToNextMarkup()
                       &&
                       recordDelimited( piDelimiter )
                       &&
                       recordDelimited( cdataDelimiter ) );
      if( !streamIsGood )
      {
        return false;
      }
    }
    return true;
  }

resetContent()

void BOL::AsciiXmlParser::resetContent ( )

inlineprotected

Definition at line 375 of file AsciiXmlParser.hpp.

  {
    rootTag.assign( "" );
    rootAttributeMap.clear();
    rootLineRange.first = -1;
    rootLineRange.second = -1;
    elementName.assign( "" );
    fullElementContentAsFound.assign( "" );
    fullOpeningTagAsFound.assign( "" );
    elementAttributeMap.clear();
    elementLineRange.first = -1;
    elementLineRange.second = -1;
    markupString.assign( "" );
    readNewlines = 0;
  }

returnToBeginningOfText()

void BOL::AsciiXmlParser::returnToBeginningOfText ( )

inline

Definition at line 299 of file AsciiXmlParser.hpp.

  {
    resetContent();
    textStream->clear();
    textStream->seekg( std::ios::beg );
  }

skipPrologAndOpenRootElement()

bool BOL::AsciiXmlParser::skipPrologAndOpenRootElement ( )

protected

Definition at line 418 of file AsciiXmlParser.cpp.

  {
    resetContent();
    // the XML declaration markup is skipped as it is a special case of
    // processing instruction markup.
    while( markupString.empty() )
    {
      streamIsGood = ( discardToNextMarkup()
                       &&
                       ignoreDelimited( commentDelimiter )
                       &&
                       ignoreDelimited( piDelimiter ) );
      if( !streamIsGood )
      {
        if( isVerbose )
        {
          std::cout
          << std::endl
          << "BOL::error! AsciiXmlParser::skipPrologAndOpenRootElement() could"
          << " not find any valid root element tag markup!";
          std::cout << std::endl;
        }
        return false;
      }
    }
    // at this point, either the current markup is the root element's opening
    // tag, or is the document declaration if there is one, either only up to
    // the 1st '>' regardless of if it actually is the end of the markup or
    // not (e.g. if it is within quotes).
    if( ( doctypeDelimiter.first.size() < ( markupString.size() + 2 ) )
        &&
        compareMarkupStart( doctypeDelimiter.first ) )
      // if the markup is a document type declaration...
    {
      // since we will discard the document type declaration, it doesn't matter
      // if we mangle markupString in doing so, since it will be over-written
      // the opening tag of the root element anyway.
      streamIsGood = eraseQuotedStringsInMarkup( 0 );
      if( !streamIsGood )
      {
        if( isVerbose )
        {
          std::cout
          << std::endl
          << "BOL::error! AsciiXmlParser::skipPrologAndOpenRootElement() could"
          << " not find any valid root element tag markup!";
          std::cout << std::endl;
        }
        return false;
      }
      size_t unclosedSubmarkupOpener( markupString.find( markupOpener ) );
      while( std::string::npos != unclosedSubmarkupOpener )
      {
        previousLength = markupString.size();
        streamIsGood = ( recordTo( markupString,
                                   markupCloser )
                         &&
                         eraseQuotedStringsInMarkup( previousLength ) );
        if( !streamIsGood )
        {
          if( isVerbose )
          {
            std::cout
            << std::endl
            << "BOL::error! AsciiXmlParser::skipPrologAndOpenRootElement()"
            << " could not find any valid root element tag markup!";
            std::cout << std::endl;
          }
          return false;
        }
        unclosedSubmarkupOpener = markupString.find( markupOpener,
                                                     unclosedSubmarkupOpener );
      }
      markupString.assign( "" );
      // at this point, we have read in an unquoted '>' for every '<'. now we
      // can forget the mangled document type declaration & we only have to
      // discard any more comments or processing instructions before the
      // opening tag of the root element.
      while( markupString.empty() )
      {
        streamIsGood = ( discardToNextMarkup()
                         &&
                         ignoreDelimited( commentDelimiter )
                         &&
                         ignoreDelimited( piDelimiter ) );
        if( !streamIsGood )
        {
          if( isVerbose )
          {
            std::cout
            << std::endl
            << "BOL::error! AsciiXmlParser::skipPrologAndOpenRootElement()"
            << " could not find any valid root element tag markup!";
            std::cout << std::endl;
          }
          return false;
        }
      }
    }
    // at this point, the current markup is the root element's opening tag,
    // though only up to the 1st '>' regardless of if it actually is the end of
    // the markup or not (e.g. if it is within quotes).
    rootLineRange.first = ( readNewlines + 1 );
    streamIsGood = ( parseTagName( elementName )
                     &&
                     parseAttributes() );
    if( !streamIsGood )
    {
      if( isVerbose )
      {
        std::cout
        << std::endl
        << "BOL::error! AsciiXmlParser::skipPrologAndOpenRootElement() could"
        << " not find any valid root element tag markup!";
        std::cout << std::endl;
      }
      return false;
    }
    rootAttributeMap = elementAttributeMap;
    rootTag.assign( elementName );
    return true;
  }

Member Data Documentation

allowedXmlQuoteChars

std::string const BOL::AsciiXmlParser::allowedXmlQuoteChars

staticprotected

Definition at line 97 of file AsciiXmlParser.hpp.

allowedXmlWhitespaceChars

std::string const BOL::AsciiXmlParser::allowedXmlWhitespaceChars

staticprotected

Definition at line 96 of file AsciiXmlParser.hpp.

cdataDelimiter

std::pair< std::string, std::string > const BOL::AsciiXmlParser::cdataDelimiter

staticprotected

Definition at line 101 of file AsciiXmlParser.hpp.

closingTag

std::string BOL::AsciiXmlParser::closingTag

protected

Definition at line 129 of file AsciiXmlParser.hpp.

closingTagsToFind

int BOL::AsciiXmlParser::closingTagsToFind

protected

Definition at line 130 of file AsciiXmlParser.hpp.

commentDelimiter

std::pair< std::string, std::string > const BOL::AsciiXmlParser::commentDelimiter

staticprotected

Definition at line 98 of file AsciiXmlParser.hpp.

currentAttribute

std::pair< std::string, std::string > BOL::AsciiXmlParser::currentAttribute

protected

Definition at line 128 of file AsciiXmlParser.hpp.

currentChar

char BOL::AsciiXmlParser::currentChar

protected

Definition at line 121 of file AsciiXmlParser.hpp.

currentQuoteChar

char BOL::AsciiXmlParser::currentQuoteChar

protected

Definition at line 127 of file AsciiXmlParser.hpp.

currentTagName

std::string BOL::AsciiXmlParser::currentTagName

protected

Definition at line 131 of file AsciiXmlParser.hpp.

doctypeDelimiter

std::pair< std::string, std::string > const BOL::AsciiXmlParser::doctypeDelimiter

staticprotected

Definition at line 100 of file AsciiXmlParser.hpp.

elementAttributeMap

std::map< std::string, std::string > BOL::AsciiXmlParser::elementAttributeMap

protected

Definition at line 116 of file AsciiXmlParser.hpp.

elementLineRange

std::pair< int, int > BOL::AsciiXmlParser::elementLineRange

protected

Definition at line 117 of file AsciiXmlParser.hpp.

elementName

std::string BOL::AsciiXmlParser::elementName

protected

Definition at line 110 of file AsciiXmlParser.hpp.

fileParsingStream

std::ifstream BOL::AsciiXmlParser::fileParsingStream

protected

Definition at line 104 of file AsciiXmlParser.hpp.

fullElementContentAsFound

std::string BOL::AsciiXmlParser::fullElementContentAsFound

protected

Definition at line 111 of file AsciiXmlParser.hpp.

fullOpeningTagAsFound

std::string BOL::AsciiXmlParser::fullOpeningTagAsFound

protected

Definition at line 114 of file AsciiXmlParser.hpp.

isVerbose

bool const BOL::AsciiXmlParser::isVerbose

protected

Definition at line 103 of file AsciiXmlParser.hpp.

markupCloser

char const BOL::AsciiXmlParser::markupCloser

staticprotected

Definition at line 94 of file AsciiXmlParser.hpp.

markupOpener

char const BOL::AsciiXmlParser::markupOpener

staticprotected

Definition at line 93 of file AsciiXmlParser.hpp.

markupString

std::string BOL::AsciiXmlParser::markupString

protected

Definition at line 119 of file AsciiXmlParser.hpp.

newlinesBeforeMarkup

int BOL::AsciiXmlParser::newlinesBeforeMarkup

protected

Definition at line 123 of file AsciiXmlParser.hpp.

parseEnd

size_t BOL::AsciiXmlParser::parseEnd

protected

Definition at line 125 of file AsciiXmlParser.hpp.

parseStart

size_t BOL::AsciiXmlParser::parseStart

protected

Definition at line 124 of file AsciiXmlParser.hpp.

piDelimiter

std::pair< std::string, std::string > const BOL::AsciiXmlParser::piDelimiter

staticprotected

Definition at line 99 of file AsciiXmlParser.hpp.

previousLength

size_t BOL::AsciiXmlParser::previousLength

protected

Definition at line 126 of file AsciiXmlParser.hpp.

readNewlines

int BOL::AsciiXmlParser::readNewlines

protected

Definition at line 122 of file AsciiXmlParser.hpp.

rootAttributeMap

std::map< std::string, std::string > BOL::AsciiXmlParser::rootAttributeMap

protected

Definition at line 108 of file AsciiXmlParser.hpp.

rootLineRange

std::pair< int, int > BOL::AsciiXmlParser::rootLineRange

protected

Definition at line 109 of file AsciiXmlParser.hpp.

rootTag

std::string BOL::AsciiXmlParser::rootTag

protected

Definition at line 107 of file AsciiXmlParser.hpp.

streamIsGood

bool BOL::AsciiXmlParser::streamIsGood

protected

Definition at line 120 of file AsciiXmlParser.hpp.

stringParsingStream

std::istringstream BOL::AsciiXmlParser::stringParsingStream

protected

Definition at line 105 of file AsciiXmlParser.hpp.

tagCloser

char const BOL::AsciiXmlParser::tagCloser

staticprotected

Definition at line 95 of file AsciiXmlParser.hpp.

textStream

std::istream* BOL::AsciiXmlParser::textStream

protected

Definition at line 106 of file AsciiXmlParser.hpp.

---

The documentation for this class was generated from the following files:

• AsciiXmlParser.hpp
• AsciiXmlParser.cpp