XmlWriter.h

/*
 * Copyright (C) 2005-2013 Marc Boris Duerner
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 * 
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef Pt_Xml_XmlWriter_h
#define Pt_Xml_XmlWriter_h

#include <Pt/Xml/Api.h>
#include <Pt/String.h>
#include <Pt/TextStream.h>
#include <cstddef>

namespace Pt {

namespace Xml {

PT_XML_API void xmlEncode(std::basic_ostream<Pt::Char>& os, const Pt::Char* str, std::size_t n);

PT_XML_API void xmlEncode(std::basic_ostream<Pt::Char>& os, const Pt::Char* str);

inline void xmlEncode(std::basic_ostream<Pt::Char>& os, const Pt::String& str);

class PT_XML_API XmlWriter
{
    public:
        XmlWriter();

        XmlWriter(std::basic_ostream<Char>& os);

        ~XmlWriter();

        bool isFormatting() const;
        
        void setFormatting(bool value);

        const Pt::String& indent() const;

        void setIndent(const Pt::String& indent);

        Pt::Char quote() const;

        void setQuote(Pt::Char ch);

        void reset();

        void reset(std::basic_ostream<Char>& os);

        std::basic_ostream<Char>* output();

        std::size_t depth() const;

        void setDefaultNamespace(const Pt::String& ns);

        void setNamespacePrefix(const Pt::String& prefix, const Pt::String& ns);

        void writeStartDocument(const Pt::Char* version, std::size_t versionSize, 
                                const Pt::Char* encoding, std::size_t encodingSize, bool standalone = false);

        void writeStartDocument(const Pt::String& version, const Pt::String& encoding, bool standalone = false);

        void writeEndDocument();

        void writeDocType(const Pt::Char* dtd, std::size_t n);

        void writeDocType(const Pt::String& dtd);

        void writeStartElement(const Pt::Char* localName, std::size_t localNameSize);

        void writeStartElement(const Pt::String& localName);

        void writeStartElement(const Char* ns, std::size_t nsSize,
                               const Char* localName, std::size_t localNameSize);

        void writeStartElement(const Pt::String& ns, const Pt::String& localName);

        void writeAttribute(const Char* localName, std::size_t localNameSize,
                            const Char* value, std::size_t valueSize);

        void writeAttribute(const Pt::String& localName, const Pt::String& value);

        void writeAttribute(const Char* ns, std::size_t nsSize,
                            const Char* localName, std::size_t localNameSize,
                            const Char* value, std::size_t valueSize);

        void writeAttribute(const Pt::String& ns, const Pt::String& localName, const Pt::String& value);

        void writeEmptyElement(const Pt::Char* localName, std::size_t localNameSize);

        void writeEmptyElement(const Pt::String& localName);

        void writeEmptyElement(const Char* ns, std::size_t nsSize,
                               const Char* localName, std::size_t localNameSize);

        void writeEmptyElement(const Pt::String& ns, const Pt::String& localName);

        void writeEndElement();

        void writeCharacters(const Pt::Char* text, std::size_t n);

        void writeCharacters(const Pt::String& text);

        void writeEntityReference(const Pt::Char* name, std::size_t n);

        void writeEntityReference(const Pt::String& name);

        void writeCData(const Pt::Char* text, std::size_t n);

        void writeCData(const Pt::String& text);

        void writeComment(const Pt::Char* text, std::size_t n);
        
        void writeComment(const Pt::String& text);

        void writeProcessingInstruction(const Pt::Char* target, std::size_t targetSize,
                                        const Pt::Char* data, std::size_t dataSize);
        
        void writeProcessingInstruction(const Pt::String& text, const Pt::String& data);

        void writeStartTag(const Pt::Char* name);

        void writeEndTag(const Pt::Char* name);

    private:
        class XmlWriterImpl* _impl;
};


inline void xmlEncode(std::basic_ostream<Pt::Char>& os, const Pt::String& str)
{
    xmlEncode(os, str.c_str(), str.size());
}


inline void XmlWriter::writeStartDocument(const Pt::String& version, const Pt::String& encoding, bool standalone)
{
    this->writeStartDocument(version.c_str(), version.size(),
                             encoding.c_str(), encoding.size(), standalone);
}


inline void XmlWriter::writeDocType(const Pt::String& dtd)
{
    this->writeDocType(dtd.c_str(), dtd.size());
}


inline void XmlWriter::writeStartElement(const Pt::String& localName)
{
    this->writeStartElement(localName.c_str(), localName.size());
}


inline void XmlWriter::writeStartElement(const Pt::String& ns, const Pt::String& localName)
{
    this->writeStartElement(ns.c_str(), ns.size(), 
                            localName.c_str(), localName.size());
}


inline void XmlWriter::writeAttribute(const Pt::String& localName, const Pt::String& value)
{
    this->writeAttribute( localName.c_str(), localName.size(), 
                          value.c_str(), value.size() );
}


inline void XmlWriter::writeAttribute(const Pt::String& ns, const Pt::String& localName, const Pt::String& value)
{
    this->writeAttribute( ns.c_str(), ns.size(), 
                          localName.c_str(), localName.size(), 
                          value.c_str(), value.size() );
}


inline void XmlWriter::writeEmptyElement(const Pt::String& localName)
{
    this->writeEmptyElement(localName.c_str(), localName.size());
}


inline void XmlWriter::writeEmptyElement(const Pt::String& ns, const Pt::String& localName)
{
    this->writeEmptyElement(ns.c_str(), ns.size(), 
                            localName.c_str(), localName.size());
}


inline void XmlWriter::writeCharacters(const Pt::String& text)
{
    this->writeCharacters(text.c_str(), text.size());
}


inline void XmlWriter::writeEntityReference(const Pt::String& name)
{
    this->writeEntityReference(name.c_str(), name.size());
}


inline void XmlWriter::writeCData(const Pt::String& text)
{
    this->writeCData(text.c_str(), text.size());
}


inline void XmlWriter::writeComment(const Pt::String& text)
{
    this->writeComment(text.c_str(), text.size());
}


inline void XmlWriter::writeProcessingInstruction(const Pt::String& target, const Pt::String& data)
{
    this->writeProcessingInstruction( target.c_str(), target.size(), 
                                      data.c_str(), data.size() );
}

} // namespace Xml

} // namespace Pt

#endif // Pt_Xml_XmlWriter_h