xmlprinter.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef __TEXTWOLF_XML_PRINTER_HPP__
#define __TEXTWOLF_XML_PRINTER_HPP__
#include "textwolf/cstringiterator.hpp"
#include "textwolf/textscanner.hpp"
#include "textwolf/xmlscanner.hpp"
#include "textwolf/charset.hpp"
#include "textwolf/xmltagstack.hpp"
#include <cstring>
#include <cstdlib>

namespace textwolf {

template <class IOCharset, class AppCharset,class BufferType>
class XMLPrinter
{
public:
        void printToBuffer( const char* src, std::size_t srcsize, BufferType& buf) const
        {
                CStringIterator itr( src, srcsize);
                TextScanner<CStringIterator,AppCharset> ts( itr);

                UChar ch;
                while ((ch = ts.chr()) != 0)
                {
                        m_output.print( ch, buf);
                        ++ts;
                }
        }

        void printEsc( char ch, BufferType& buf, unsigned int nof_echr, const char* echr, const char** estr) const
        {
                const char* cc = (const char*)memchr( echr, ch, nof_echr);
                if (cc)
                {
                        unsigned int ii = 0;
                        const char* tt = estr[ cc-echr];
                        while (tt[ii]) m_output.print( tt[ii++], buf);
                }
                else
                {
                        m_output.print( ch, buf);
                }
        }

        void printToBufferSubstChr( const char* src, std::size_t srcsize, BufferType& buf, unsigned int nof_echr, const char* echr, const char** estr) const
        {
                CStringIterator itr( src, srcsize);
                textwolf::TextScanner<CStringIterator,AppCharset> ts( itr);

                textwolf::UChar ch;
                while ((ch = ts.chr()) != 0)
                {
                        if (ch < 128)
                        {
                                printEsc( (char)ch, buf, nof_echr, echr, estr);
                        }
                        else
                        {
                                m_output.print( ch, buf);
                        }
                        ++ts;
                }
        }

        void printToBufferAttributeValue( const char* src, std::size_t srcsize, BufferType& buf) const
        {
                enum {nof_echr = 12};
                static const char* estr[nof_echr] = {"&lt;", "&gt;", "&apos;", "&quot;", "&amp;", "&#0;", "&#8;", "&#9;", "&#10;", "&#13;"};
                static const char echr[nof_echr+1] = "<>'\"&\0\b\t\n\r";
                m_output.print( '"', buf);
                printToBufferSubstChr( src, srcsize, buf, nof_echr, echr, estr);
                m_output.print( '"', buf);
        }

        void printToBufferContent( const char* src, std::size_t srcsize, BufferType& buf) const
        {
                enum {nof_echr = 6};
                static const char* estr[nof_echr] = {"&lt;", "&gt;", "&amp;", "&#0;", "&#8;"};
                static const char echr[nof_echr+1] = "<>&\0\b";
                printToBufferSubstChr( src, srcsize, buf, nof_echr, echr, estr);
        }

        void printToBuffer( char ch, BufferType& buf) const
        {
                m_output.print( (textwolf::UChar)(unsigned char)ch, buf);
        }

public:
        explicit XMLPrinter( bool subDocument=false)
                :m_state(subDocument?Content:Init),m_lasterror(0){}

        explicit XMLPrinter( const IOCharset& output_, bool subDocument=false)
                :m_state(subDocument?Content:Init),m_output(output_),m_lasterror(0){}

        XMLPrinter( const XMLPrinter& o)
                :m_state(o.m_state),m_tagstack(o.m_tagstack),m_output(o.m_output),m_lasterror(o.m_lasterror)
        {}

        void reset( bool subDocument=false)
        {
                m_state = subDocument?Content:Init;
                m_tagstack.clear();
                m_lasterror = 0;
        }

        bool printHeader( const char* encoding, const char* standalone, BufferType& buf)
        {
                if (m_state != Init)
                {
                        m_lasterror = "printing xml header not at the beginning of the document";
                        return false;
                }
                std::string enc = encoding?encoding:"UTF-8";
                printToBuffer( "<?xml version=\"1.0\" encoding=\"", 30, buf);
                printToBuffer( enc.c_str(), enc.size(), buf);
                if (standalone)
                {
                        printToBuffer( "\" standalone=\"", 14, buf);
                        printToBuffer( standalone, std::strlen(standalone), buf);
                        printToBuffer( "\"?>\n", 4, buf);
                }
                else
                {
                        printToBuffer( "\"?>\n", 4, buf);
                }
                m_state = Content;
                return true;
        }

        bool printDoctype( const char* rootid, const char* publicid, const char* systemid, BufferType& buf)
        {
                if (rootid)
                {
                        if (publicid)
                        {
                                if (!systemid)
                                {
                                        m_lasterror = "defined DOCTYPE with PUBLIC id but no SYSTEM id";
                                        return false;
                                }
                                printToBuffer( "<!DOCTYPE ", 10, buf);
                                printToBuffer( rootid, std::strlen( rootid), buf);
                                printToBuffer( " PUBLIC \"", 9, buf);
                                printToBuffer( publicid, std::strlen( publicid), buf);
                                printToBuffer( "\" \"", 3, buf);
                                printToBuffer( systemid, std::strlen( systemid), buf);
                                printToBuffer( "\">", 2, buf);
                        }
                        else if (systemid)
                        {
                                printToBuffer( "<!DOCTYPE ", 10, buf);
                                printToBuffer( rootid, std::strlen( rootid), buf);
                                printToBuffer( " SYSTEM \"", 9, buf);
                                printToBuffer( systemid, std::strlen( systemid), buf);
                                printToBuffer( "\">", 2, buf);
                        }
                        else
                        {
                                printToBuffer( "<!DOCTYPE ", 11, buf);
                                printToBuffer( rootid, std::strlen( rootid), buf);
                                printToBuffer( ">", 2, buf);
                        }
                }
                return true;
        }

        bool exitTagContext( BufferType& buf)
        {
                if (m_state != Content)
                {
                        if (m_state == Init)
                        {
                                m_lasterror = "printed xml without root element";
                                return false;
                        }
                        printToBuffer( '>', buf);
                        m_state = Content;
                }
                return true;
        }

        bool printOpenTag( const char* src, std::size_t srcsize, BufferType& buf)
        {
                if (!exitTagContext( buf)) return false;
                printToBuffer( '<', buf);
                printToBuffer( (const char*)src, srcsize, buf);

                m_tagstack.push( src, srcsize);
                m_state = TagElement;
                return true;
        }

        bool printAttribute( const char* src, std::size_t srcsize, BufferType& buf)
        {
                if (m_state == TagElement)
                {
                        printToBuffer( ' ', buf);
                        printToBuffer( (const char*)src, srcsize, buf);
                        printToBuffer( '=', buf);
                        m_state = TagAttribute;
                        return true;
                }
                return false;
        }

        bool printValue( const char* src, std::size_t srcsize, BufferType& buf)
        {
                if (m_state == TagAttribute)
                {
                        printToBufferAttributeValue( (const char*)src, srcsize, buf);
                        m_state = TagElement;
                }
                else
                {
                        if (!exitTagContext( buf)) return false;
                        printToBufferContent( (const char*)src, srcsize, buf);
                }
                return true;
        }

        bool printCloseTag( BufferType& buf)
        {
                const void* cltag;
                std::size_t cltagsize;

                if (!m_tagstack.top( cltag, cltagsize) || !cltagsize)
                {
                        return false;
                }
                if (m_state == TagElement)
                {
                        printToBuffer( '/', buf);
                        printToBuffer( '>', buf);
                        m_state = Content;
                }
                else if (m_state != Content)
                {
                        return false;
                }
                else
                {
                        printToBuffer( '<', buf);
                        printToBuffer( '/', buf);
                        printToBuffer( (const char*)cltag, cltagsize, buf);
                        printToBuffer( '>', buf);
                }
                m_tagstack.pop();
                if (m_tagstack.empty())
                {
                        printToBuffer( '\n', buf);
                }
                return true;
        }

        enum State
        {
                Init,
                Content,
                TagAttribute,
                TagElement
        };

        State state() const
        {
                return m_state;
        }

        const char* lasterror() const
        {
                return m_lasterror;
        }

private:
        State m_state;                                  
        TagStack m_tagstack;                            
        IOCharset m_output;                             
        const char* m_lasterror;                        
};

} //namespace
#endif