writeobj.cpp

Go to the documentation of this file.

// See ../../license.txt for license information.
//
// writeobj.cpp
//
// NOTES
//              A concrete subclass of object_writer which dumps an object.
//
//      We write the objects like this:
//
/*
        object ::=  
                object-start
                        sub-object-list
                object-end
                
        object-start ::=
                "<" TAGNAME ["(" attr-list ")"] ">"

        object-end ::=
                "</" TAGNAME ">"

        sub-object-list ::=
                (data-object | object)*

        data-object ::=
                "<" TAGNAME ">" data "</" TAGNAME ">"
                 
        attr-list ::= 
                [attr-pair ([", " attr-pair])*]
                                
        attr-pair ::=
                name "=" value
*/
// 21-Jul-2003  phamilton  Created
//

#define PERSIST_IN_LIBRARY_SOURCE
#include "writeobj.hpp"

using namespace ph::persist::xml;

bool writeobj::start(const std::string &tagname)
/*
        The input to start and end is "TAGNAME". The state table for the
        tree must start from TAGNAME and work out.
*/
{
        // write out the XML declaration at the top.
        if (_start)
        {
                *_stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" << std::endl << std::endl;
                _start = false;
        }
        
        // Close off the previous tag (if there is one).
        if (!_tagname.empty())
        {
                if (_data.empty())
                {
                        //      object ::=  
                        //              object-start
                        //                      ...
                        object_start();
                        _tabs++;
                }
                else
                        data_object();
        }
        
        // and get started for the next tag.
        _attrs.clear();
        _tagname = tagname;
        _data = "";
        
        return true;
}

bool writeobj::end(const std::string &tagname)
{
        // close off the current tag (if there is one).
        if (_tagname.empty())
        {
                /*
                        object ::=  
                                        ...
                                object-end
                */
                // there was no accumulated tagname, just unnest,
                _tabs--;
                object_end(tagname);
        }
        else
        {
                if (_data.empty())
                {
                        /*
                                object ::=  
                                        object-start
                                                ...
                                        object-end
                        */
                        // the last tag had no data, so the last one was an object.
                        object_start();
                        object_end(tagname);
                }
                else
                        data_object();
        }
                
        _attrs.clear();
        _tagname = "";
        _data = "";
        
        return true;
}

bool writeobj::attr(const std::string &name, const std::string &value)
{
        if (_tagname.empty())
        {
                *_console << "bad state detected in attr(). _tagname should not be empty." << std::endl;
                return false;
        }
        if (!_data.empty())
        {
                *_console << "bad state detected in attr(). _data should be empty." << std::endl;
                return false;
        }
        // and save this attribute.
        _attrs[name] = value;
        return true;
}

bool writeobj::data(const std::string &d)
{
        if (!_data.empty())
        {
                *_console << "bad state detected in data(). _data should be empty." << std::endl;
                return false;
        }
        // and save this data.
        _data = d;
        return true;
}

void writeobj::object_start()
/*
        object-start ::=
                "<" TAGNAME ["(" attr-list ")"] ">"

        attr-list ::= 
                [attr-pair ([", " attr-pair])*]
                                
        attr-pair ::=
                name "=" "\"" value "\""
*/
{
        if (_tagname.empty())
        {
                *_console << "bad state detected in object_decl(). _tagname should not be empty." << std::endl;
                return;
        }
        tabs();
        *_stream << "<" << _tagname;
        if (!_attrs.empty())
        {
                *_stream << " ";
                // how about a std::for_each for this guy. What would be the best way?
                for (std::map<std::string, std::string>::iterator i=_attrs.begin(); i != _attrs.end(); i++)
                {
                        if (i != _attrs.begin())
                                *_stream << ", ";
                        *_stream << i->first << "=\"" << i->second << "\"";
                }
        }
        *_stream << ">";
        cr();
}

void writeobj::object_end(const std::string &tagname)
/*
        object-end ::=
                "</" TAGNAME ">"
*/
{
        tabs();
        *_stream << "</" << tagname << ">";
        cr();
}

void writeobj::data_object()
/*
        data-object ::=
                "<" TAGNAME ">" data "</" TAGNAME ">"
*/
{
        tabs(); *_stream << "<" << _tagname << ">" << _data << "</" << _tagname << ">"; cr();
}

void writeobj::tabs()
{
        for (int i=0; i<_tabs; i++)
                *_stream << "  ";
}

void writeobj::cr()
{
        *_stream << std::endl;
}

---