XMLStorage::XMLReaderBase Struct Reference

XML reader base class. More...

#include <xmlstorage.h>

Inheritance diagram for XMLStorage::XMLReaderBase:

Collaboration diagram for XMLStorage::XMLReaderBase:

Public Member Functions
	XMLReaderBase (XMLNode *node)
virtual	~XMLReaderBase ()
bool	parse ()
void	read ()
	read XML stream into XML tree below _pos
std::string	get_position () const
	return current parser position as string
const XMLFormat &	get_format () const
const char *	get_endl () const
const XMLErrorList &	get_errors () const
const XMLErrorList &	get_warnings () const
void	clear_errors ()

Protected Types
enum	{ TAG_NONE , TAG_START , TAG_END }

Protected Member Functions
virtual int	get ()=0
int	eat_endl ()
void	finish_read ()
virtual void	XmlDeclHandler (const char *version, const char *encoding, int standalone)
	store XML version and encoding into XML reader
virtual void	StartElementHandler (const XS_String &name, const XMLNode::AttributeMap &attributes)
	notifications about XML start tag
virtual void	EndElementHandler ()
	notifications about XML end tag
virtual void	DefaultHandler (const std::string &s)
	store content, white space and comments

Protected Attributes
XMLPos	_pos
std::string	_content
enum XMLStorage::XMLReaderBase:: { ... }	_last_tag
XMLErrorList	_errors
XMLErrorList	_warnings
XMLFormat	_format
bool	_endl_defined
bool	_utf8

Detailed Description

XML reader base class.

Definition at line 2414 of file xmlstorage.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Enumerator
TAG_NONE
TAG_START
TAG_END

Definition at line 2506 of file xmlstorage.h.

{TAG_NONE, TAG_START, TAG_END} _last_tag;

Constructor & Destructor Documentation

XMLReaderBase()

XMLStorage::XMLReaderBase::XMLReaderBase ( XMLNode *  node )

inline

Definition at line 2464 of file xmlstorage.h.

     :  _pos(node),
        _endl_defined(false),
        _utf8(false)
    {
        _last_tag = TAG_NONE;
    }

~XMLReaderBase()

XMLStorage::XMLReaderBase::~XMLReaderBase ( )

virtual

Definition at line 54 of file xs-native.cpp.

{
}

Member Function Documentation

clear_errors()

void XMLStorage::XMLReaderBase::clear_errors ( )

inline

Definition at line 2490 of file xmlstorage.h.

{_errors.clear(); _warnings.clear();}

DefaultHandler()

void XMLStorage::XMLReaderBase::DefaultHandler ( const std::string &  s )

protectedvirtual

store content, white space and comments

Definition at line 434 of file xs-native.cpp.

{
    _content.append(s);
}

eat_endl()

int XMLStorage::XMLReaderBase::eat_endl ( )

protected

Definition at line 389 of file xs-native.cpp.

{
    int c = get();
 
    if (c == '\r')
        c = get();
 
    if (c == '\n')
        c = get();
 
    return c;
}

Referenced by parse().

EndElementHandler()

void XMLStorage::XMLReaderBase::EndElementHandler ( )

protectedvirtual

notifications about XML end tag

Definition at line 899 of file xmlstorage.cpp.

{
    const char* s = _content.c_str();
    const char* e = s + _content.length();
    const char* p;
 
    if (!strncmp(s,CDATA_START,9) && !strncmp(e-3,CDATA_END,3)) {
        s += 9;
        p = (e-=3);
 
        _pos->_cdata_content = true;
    } else {
         // search for content end leaving only white space for _end_leading
        for(p=e; p>s; --p)
            if (!isspace((unsigned char)p[-1]))
                break;
 
        _pos->_cdata_content = false;
    }
 
    if (p != s) {
        if (_pos->_children.empty())    // no children in current node?
            _pos->_content.append(s, p-s);
        else if (_last_tag == TAG_START)
            _pos->_content.append(s, p-s);
        else
            _pos->_children.back()->_trailing.append(s, p-s);
    }
 
    if (p != e)
        _pos->_end_leading.assign(p, e-p);
 
    _pos.back();
 
    _last_tag = TAG_END;
    _content.erase();
}

Referenced by parse().

finish_read()

void XMLStorage::XMLReaderBase::finish_read ( )

protected

Definition at line 831 of file xmlstorage.cpp.

{
    if (_pos->_children.empty())
        _pos->_trailing.append(_content);
    else
        _pos->_children.back()->_trailing.append(_content);
 
    _content.erase();
}

Referenced by read().

get()

virtual int XMLStorage::XMLReaderBase::get ( )

protectedpure virtual

Implemented in XMLStorage::XMLReader.

Referenced by eat_endl(), and parse().

get_endl()

const char * XMLStorage::XMLReaderBase::get_endl ( ) const

inline

Definition at line 2485 of file xmlstorage.h.

{return _endl_defined? _format._endl: "\n";}

get_errors()

const XMLErrorList & XMLStorage::XMLReaderBase::get_errors ( ) const

inline

Definition at line 2487 of file xmlstorage.h.

{return _errors;}

get_format()

const XMLFormat & XMLStorage::XMLReaderBase::get_format ( ) const

inline

Definition at line 2484 of file xmlstorage.h.

{return _format;}

get_position()

std::string XMLStorage::XMLReaderBase::get_position

(

)

const

return current parser position as string

Definition at line 403 of file xs-native.cpp.

{
/*@TODO display parser position in case of errors
    int line = XML_GetCurrentLineNumber(_parser);
    int column = XML_GetCurrentColumnNumber(_parser);
 
    std::ostringstream out;
    out << "(" << line << ") : [column " << column << "]";
 
    return out.str();
*/
    return "";
}

get_warnings()

const XMLErrorList & XMLStorage::XMLReaderBase::get_warnings ( ) const

inline

Definition at line 2488 of file xmlstorage.h.

{return _warnings;}

parse()

bool XMLStorage::XMLReaderBase::parse

(

)

Definition at line 226 of file xs-native.cpp.

{
    Buffer buffer;
    int c = get();
    bool in_comment = false;
 
    while(c != EOF) {
        if (in_comment || c=='<') {
            buffer.append(c);
 
             // read start or end tag
            for(;;) {
                c = get();
 
                if (c == EOF)
                    break;
 
                buffer.append(c);
 
                if (c == '>')
                    break;
            }
 
            const std::string& b = buffer.str(_utf8);
            const char* str = b.c_str();
 
            if (in_comment || !strncmp(str+1, "!--", 3)) {
                 // XML comment
                DefaultHandler(b);
 
                if (strcmp(str+b.length()-3, "-->"))
                    in_comment = true;
                else
                    in_comment = false;
 
                c = get();
            } else if (str[1] == '/') {
                 // end tag
 
                /*@TODO error handling
                const XS_String& tag = buffer.get_tag();
 
                    if (tag != last_opened_tag) {
                        ERROR
                    }
                */
 
                EndElementHandler();
 
                c = get();
            } else if (str[1] == '?') {
                 // XML declaration
                const XS_String& tag = buffer.get_tag();
 
                if (tag == "?xml") {
                    XMLNode::AttributeMap attributes;
                    buffer.get_attributes(attributes);
 
                    const std::string& version = attributes.get("version");
                    const std::string& encoding = attributes.get("encoding");
 
                    int standalone;
                    XMLNode::AttributeMap::const_iterator found =   // const_cast for ISO C++ compatibility error of GCC
                            const_cast<const XMLNode::AttributeMap&>(attributes).find("standalone");
                    if (found != attributes.end())
                        standalone = !XS_icmp(found->second.c_str(), XS_TEXT("yes"));
                    else
                        standalone = -1;
 
                    XmlDeclHandler(version.empty()?NULL:version.c_str(), encoding.empty()?NULL:encoding.c_str(), standalone);
 
                    if (!encoding.empty() && !_stricmp(encoding.c_str(), "utf-8"))
                        _utf8 = true;
 
                    c = eat_endl();
                } else if (tag == "?xml-stylesheet") {
                    XMLNode::AttributeMap attributes;
                    buffer.get_attributes(attributes);
 
                    StyleSheet stylesheet(attributes.get("href"), attributes.get("type"), !XS_icmp(attributes.get("alternate"), XS_TEXT("yes")));
                    stylesheet._title = attributes.get("title");
                    stylesheet._media = attributes.get("media");
                    stylesheet._charset = attributes.get("charset");
 
                    _format._stylesheets.push_back(stylesheet);
 
                    c = eat_endl();
                } else {
                    DefaultHandler(b);
                    c = get();
                }
            } else if (str[1] == '!') {
                if (!strncmp(str+2, "DOCTYPE ", 8)) {
                    _format._doctype.parse(str+10);
 
                    c = eat_endl();
                } else if (!strncmp(str+2, "[CDATA[", 7)) { // see CDATA_START
                     // parse <![CDATA[ ... ]]> strings
                    while(!buffer.has_CDEnd()) {
                        c = get();
 
                        if (c == EOF)
                            break;
 
                        buffer.append(c);
                    }
 
                    DefaultHandler(buffer.str(_utf8));
 
                    c = get();
                }
            } else {
                 // start tag
                const XS_String& tag = buffer.get_tag();
 
                if (!tag.empty()) {
                    XMLNode::AttributeMap attributes;
                    buffer.get_attributes(attributes);
 
                    StartElementHandler(tag, attributes);
 
                    if (str[b.length()-2] == '/')
                        EndElementHandler();
                }
 
                c = get();
            }
        } else {
            buffer.append(c);
 
             // read white space
            for(;;) {
                 // check for the encoding of the first line end
                if (!_endl_defined) {
                    if (c == '\n') {
                        _format._endl = "\n";
                        _endl_defined = true;
                    } else if (c == '\r') {
                        _format._endl = "\r\n";
                        _endl_defined = true;
                    }
                }
 
                c = get();
 
                if (c == EOF)
                    break;
 
                if (c == '<')
                    break;
 
                buffer.append(c);
            }
 
            DefaultHandler(buffer.str(_utf8));
        }
 
        buffer.reset();
    }
 
    return true; //TODO return false on invalid XML
}

Referenced by read().

read()

void XMLStorage::XMLReaderBase::read

(

)

read XML stream into XML tree below _pos

Definition at line 59 of file xs-native.cpp.

{
    if (!parse()) {
        XMLError error;
 
        error._message = "XML parsing error";
        //error._line = ;
        //error._column = ;
 
        _errors.push_back(error);
    }
 
    finish_read();
}

StartElementHandler()

void XMLStorage::XMLReaderBase::StartElementHandler ( const XS_String &  name, const XMLNode::AttributeMap &  attributes  )

protectedvirtual

notifications about XML start tag

Definition at line 856 of file xmlstorage.cpp.

{
    const char* s = _content.c_str();
    const char* e = s + _content.length();
    const char* p = s;
 
     // search for content end leaving only white space for leading
    for(p=e; p>s; --p)
        if (!isspace((unsigned char)p[-1]))
            break;
 
    if (p != s) {
        if (_pos->_children.empty()) {  // no children in last node?
            if (_last_tag == TAG_START)
                _pos->_content.append(s, p-s);
            else if (_last_tag == TAG_END)
                _pos->_trailing.append(s, p-s);
            else // TAG_NONE at root node
                p = s;
        } else
            _pos->_children.back()->_trailing.append(s, p-s);
    }
 
    std::string leading;
 
    if (p != e)
        leading.assign(p, e-p);
 
    XMLNode* node = new XMLNode(name, leading);
 
    _pos.add_down(node);
 
#ifdef XMLNODE_LOCATION
    node->_location = get_location();
#endif
 
    node->_attributes = attributes;
 
    _last_tag = TAG_START;
    _content.erase();
}

Referenced by parse().

XmlDeclHandler()

void XMLStorage::XMLReaderBase::XmlDeclHandler ( const char *  version, const char *  encoding, int  standalone  )

protectedvirtual

store XML version and encoding into XML reader

Definition at line 843 of file xmlstorage.cpp.

{
    if (version)
        _format._version = version;
 
    if (encoding)
        _format._encoding = encoding;
 
    _format._standalone = standalone;
}

Referenced by parse().

Member Data Documentation

_content

std::string XMLStorage::XMLReaderBase::_content

protected

Definition at line 2505 of file xmlstorage.h.

Referenced by DefaultHandler(), EndElementHandler(), finish_read(), and StartElementHandler().

_endl_defined

bool XMLStorage::XMLReaderBase::_endl_defined

protected

Definition at line 2512 of file xmlstorage.h.

Referenced by get_endl(), and parse().

_errors

XMLErrorList XMLStorage::XMLReaderBase::_errors

protected

Definition at line 2508 of file xmlstorage.h.

Referenced by clear_errors(), get_errors(), and read().

_format

XMLFormat XMLStorage::XMLReaderBase::_format

protected

Definition at line 2511 of file xmlstorage.h.

Referenced by get_endl(), get_format(), parse(), and XmlDeclHandler().

enum { ... } XMLStorage::XMLReaderBase::_last_tag

Referenced by EndElementHandler(), StartElementHandler(), and XMLReaderBase().

_pos

XMLPos XMLStorage::XMLReaderBase::_pos

protected

Definition at line 2503 of file xmlstorage.h.

Referenced by EndElementHandler(), finish_read(), and StartElementHandler().

_utf8

bool XMLStorage::XMLReaderBase::_utf8

protected

Definition at line 2522 of file xmlstorage.h.

Referenced by parse().

_warnings

XMLErrorList XMLStorage::XMLReaderBase::_warnings

protected

Definition at line 2509 of file xmlstorage.h.

Referenced by clear_errors(), and get_warnings().

---

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

• modules/rosapps/applications/explorer-old/utility/xmlstorage.h
• modules/rosapps/applications/explorer-old/utility/xmlstorage.cpp
• modules/rosapps/applications/explorer-old/utility/xs-native.cpp