XMLFileOutput.h

Go to the documentation of this file.

/*
 *  BEEN: Benchmarking Environment
 *  ==============================
 *
 *  File author: Branislav Repcek
 *
 *  GNU Lesser General Public License Version 2.1
 *  ---------------------------------------------
 *  Copyright (C) 2004-2006 Distributed Systems Research Group,
 *  Faculty of Mathematics and Physics, Charles University in Prague
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 */

#ifndef XML_FILE_OUTPUT_INCLUDED
#define XML_FILE_OUTPUT_INCLUDED

#include <vector>
#include "UnicodeString.h"

namespace hwdet
{

#ifdef UNICODE
    const Char DefaultEncoding[] = TXT("UTF-16");
#else
#ifdef _WINDOWS
    const Char DefaultEncoding[] = TXT("WINDOWS-1252");
#else
    const Char DefaultEncoding[] = TXT("US-ASCII");
#endif
#endif

    template< typename T > String inline ConvertToXMLString(const T &value)
    {
        StringStream stream;

        stream << value;

        return stream.str();
    }

    String inline ConvertToXMLString(const String &value)
    {
        StringStream stream;

        const String chars = TXT("&\'\"<>");
        const String reps[] = {TXT("&amp;"), TXT("&apos;"), TXT("&quot;"), TXT("&lt;"), TXT("&gt;")};

        String::const_iterator end = value.end();

        for (String::const_iterator it = value.begin(); it != end; ++it)
        {
            size_t index = chars.find(*it);
            if (index == chars.npos)
            {
                stream << (Char) *it;
            }
            else
            {
                stream << reps[index];
            }
        }

        return stream.str();
    }

    class XMLElement
    {
    public:
        XMLElement(void) :
        name(TXT("(undefined)")),
        depth(0),
        parent(NULL) 
        {
        }

        XMLElement(const Char *elem_name) :
        name(elem_name),
        depth(0),
        parent(NULL) 
        {
        }

        XMLElement(const String &elem_name) :
        name(elem_name),
        depth(0),
        parent(NULL) 
        {
        }

        virtual ~XMLElement(void)
        {
            std::vector< XMLElement * >::const_iterator end = nodes.end();

            for (std::vector< XMLElement * >::const_iterator it = nodes.begin(); it != end; ++it)
            {
                delete *it;
            }
        }

        virtual String GetNodeName(void) const
        {
            return name;
        }

        void AddSubNode(XMLElement *new_node)
        {
            if (new_node == NULL)
            {
                return;
            }

            new_node->SetNodeParent(this);
            nodes.push_back(new_node);
        }

        XMLElement *GetSubNode(const size_t index) const
        {
            if (index < nodes.size())
            {
                return nodes[index];
            }
            else
            {
                return NULL;
            }
        }

        size_t GetSubNodeCount(void) const
        {
            return nodes.size();
        }

        virtual String GetNodeValueString(void)
        {
            StringStream stream;

            std::vector< XMLElement * >::const_iterator end = nodes.end();

            for (std::vector< XMLElement * >::const_iterator it = nodes.begin(); it != end; ++it)
            {
                (*it)->AppendToStream(stream);
            }

            return stream.str();
        }

        virtual void AppendToStream(OStream &stream) const
        {
            for (size_t i = 0; i < depth; ++i)
            {
                stream << TXT("\t");
            }

            stream << TXT("<") << GetNodeName() << TXT(">") << std::endl;
            
            std::vector< XMLElement * >::const_iterator end = nodes.end();
            for (std::vector< XMLElement * >::const_iterator it = nodes.begin(); it != end; ++it)
            {
                (*it)->AppendToStream(stream);
            }
            
            for (size_t i = 0; i < depth; ++i)
            {
                stream << TXT("\t");
            }

            stream << TXT("</") << GetNodeName() << TXT(">") << std::endl;
        }

    protected:

        String                     name;

        std::vector< XMLElement* > nodes;

        size_t                     depth;

        XMLElement                 *parent;

        void SetNodeDepth(size_t nd)
        {
            depth = nd;
            std::vector< XMLElement * >::iterator end = nodes.end();

            for (std::vector< XMLElement * >::iterator it = nodes.begin(); it != end; ++it)
            {
                (*it)->SetNodeDepth(depth + 1);
            }
        }

        void SetNodeParent(XMLElement *e)
        {
            parent = e;

            if (e != NULL)
            {
                SetNodeDepth(e->depth + 1);
            }
            else
            {
                SetNodeDepth(0);
            }
        }
    };

    template< typename T >
    class XMLValueElement : public XMLElement
    {
    public:
        XMLValueElement(const Char *elem_name, const T elem_value) :
        XMLElement(elem_name),
        value(elem_value) 
        {
        }

        XMLValueElement(const String &elem_name, const T elem_value) :
        XMLElement(elem_name),
        value(elem_value) 
        {
        }

        virtual ~XMLValueElement(void)
        {
        }

        T GetNodeValue(void) const
        {
            return value;
        }

        void SetNodeValue(T new_value)
        {
            value = new_value;
        }

        String GetNodeValueString(void) const
        {
            return ConvertToXMLString(value);
        }

        virtual void AppendToStream(OStream &stream) const
        {
            for (size_t i = 0; i < depth; ++i)
            {
                stream << TXT("\t");
            }

            stream << TXT("<") << GetNodeName() << TXT(">") << GetNodeValueString() << 
                      TXT("</") << GetNodeName() << TXT(">") << std::endl;
        }

    protected:
        T           value;
    };

    class XMLOutputFile
    {
    public:
        XMLOutputFile(const Char *enc = NULL) :
        root_node(NULL),
        encoding(TXT("")) 
        {
            if (enc != NULL)
            {
                encoding = String(enc);
            }
        }

        XMLOutputFile(XMLElement *root_elem, const Char *enc = DefaultEncoding) :
        root_node(root_elem),
        encoding(enc)
        {
        }

        ~XMLOutputFile(void)
        {
        }

        bool Write(OStream &stream) const
        {
            if (encoding != String(TXT("")))
            {
                stream << TXT("<?xml version=\"1.0\" encoding=\"") << encoding << TXT("\"?>") << std::endl;
            }
            else
            {
                stream << TXT("<?xml version=\"1.0\"?>") << std::endl;
            }

            root_node->AppendToStream(stream);

            return true;
        }

        bool Write(String file_name) const
        {
            if (root_node == NULL)
            {
                return false;
            }

            OFStream file;

#if defined(_MSC_VER) && (_MSC_VER < 1400) && defined(UNICODE) && defined(_WINDOWS)
            // this is provided for older versions of Visual Studio which do not support wide char
            // strings as file names
            file.open(Win_UnicodeToANSI(file_name).c_str(), std::ios_base::out);
#else
            file.open(file_name.c_str(), std::ios_base::out);
#endif

            if (file.is_open())
            {
                if (encoding != String(TXT("")))
                {
                    file << TXT("<?xml version=\"1.0\" encoding=\"") << encoding << TXT("\"?>") << std::endl;
                }
                else
                {
                    file << TXT("<?xml version=\"1.0\"?>") << std::endl;
                }

                root_node->AppendToStream(file);
                file.close();

                return true;
            }

            return false;
        }

        void SetRootNode(XMLElement *elem)
        {
            root_node = elem;
        }

        void ClearRootNode(void)
        {
            delete root_node;
            root_node = NULL;
        }
        
        String GetEncoding(void) const
        {
            return encoding;
        }

    private:
        XMLElement  *root_node;

        String      encoding;
    };

} // namespace hwdet

#endif

---