XmlWriter.java

/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2001 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org /)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" and
 *    "Apache Commons" must not be used to endorse or promote products
 *    derived from this software without prior written permission. For
 *    written permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    "Apache Turbine", nor may "Apache" appear in their name, without
 *    prior written permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org />.
 */
package org.dbunit.util.xml;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayDeque;
import java.util.Deque;

/**
 * Makes writing XML much much easier. Improved from <a href=
 * "http://builder.com.com/article.jhtml?id=u00220020318yan01.htm&page=1&vf=tt">
 * article</a>
 *
 * @author <a href="mailto:bayard@apache.org">Henri Yandell</a>
 * @author <a href="mailto:pete@fingertipsoft.com">Peter Cassetta</a>
 * @author Last changed by: $Author$
 * @version $Revision$ $Date$
 * @since 1.0
 */
public class XmlWriter
{
    /**
     * CDATA start tag: {@value}
     */
    public static final String CDATA_START = "<![CDATA[";
    /**
     * CDATA end tag: {@value}
     */
    public static final String CDATA_END = "]]>";

    /**
     * Default encoding value which is {@value}
     */
    public static final String DEFAULT_ENCODING = "UTF-8";

    public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;

    /**
     * Logger for this class
     */
    private static final Logger logger =
            LoggerFactory.getLogger(XmlWriter.class);

    /** Underlying writer. */
    private Writer out;

    /** The encoding to be written into the XML header/metatag. */
    private Charset encoding;

    /** Of xml element names. */
    private Deque<String> stack = new ArrayDeque<>();

    /** Current attribute string. */
    private StringBuilder attrs;

    /** Is the current node empty. */
    private boolean empty;

    /** Is the current node closed.... */
    private boolean closed = true;

    /** Is pretty printing enabled?. */
    private boolean pretty = true;

    /**
     * was text the last thing output?
     */
    private boolean wroteText = false;

    /**
     * output this to indent one level when pretty printing
     */
    private String indent = "  ";

    /**
     * output this to end a line when pretty printing
     */
    private String newline = "\n";

    /**
     * Create an XmlWriter on top of an existing java.io.Writer.
     */
    public XmlWriter(final Writer writer)
    {
        this(writer, null);
    }

    /**
     * Create an XmlWriter on top of an existing java.io.Writer.
     */
    public XmlWriter(final Writer writer, final Charset charset)
    {
        setWriter(writer, charset);
    }

    /**
     * Create an XmlWriter on top of an existing {@link java.io.OutputStream}.
     *
     * @param outputStream
     * @param charset
     *         The charset to be used for writing to the given output stream.
     *         Can be <code>null</code>. If it is <code>null</code> the
     *         {@link #DEFAULT_ENCODING} is used.
     * @since 2.4
     */
    public XmlWriter(final OutputStream outputStream, Charset charset)
    {
        final Charset writerCharset =
                charset == null ? DEFAULT_CHARSET : charset;
        final OutputStreamWriter writer =
                new OutputStreamWriter(outputStream, writerCharset);
        setWriter(writer, writerCharset);
    }

    /**
     * Turn pretty printing on or off. Pretty printing is enabled by default,
     * but it can be turned off to generate more compact XML.
     *
     * @param enable
     *            true to enable, false to disable pretty printing.
     */
    public void enablePrettyPrint(final boolean enable)
    {
        if (logger.isDebugEnabled())
        {
            logger.debug("enablePrettyPrint(enable={}) - start",
                    String.valueOf(enable));
        }

        this.pretty = enable;
    }

    /**
     * Specify the string to prepend to a line for each level of indent. It is 2
     * spaces ("  ") by default. Some may prefer a single tab ("\t") or a
     * different number of spaces. Specifying an empty string will turn off
     * indentation when pretty printing.
     *
     * @param indent
     *            representing one level of indentation while pretty printing.
     */
    public void setIndent(final String indent)
    {
        logger.debug("setIndent(indent={}) - start", indent);

        this.indent = indent;
    }

    /**
     * Specify the string used to terminate each line when pretty printing. It
     * is a single newline ("\n") by default. Users who need to read generated
     * XML documents in Windows editors like Notepad may wish to set this to a
     * carriage return/newline sequence ("\r\n"). Specifying an empty string
     * will turn off generation of line breaks when pretty printing.
     *
     * @param newline
     *            representing the newline sequence when pretty printing.
     */
    public void setNewline(final String newline)
    {
        logger.debug("setNewline(newline={}) - start", newline);

        this.newline = newline;
    }

    /**
     * A helper method. It writes out an element which contains only text.
     *
     * @param name
     *            String name of tag
     * @param text
     *            String of text to go inside the tag
     */
    public XmlWriter writeElementWithText(final String name, final String text)
            throws IOException
    {
        logger.debug("writeElementWithText(name={}, text={}) - start", name,
                text);

        writeElement(name);
        writeText(text);
        return endElement();
    }

    /**
     * A helper method. It writes out empty entities.
     *
     * @param name
     *            String name of tag
     */
    public XmlWriter writeEmptyElement(final String name) throws IOException
    {
        logger.debug("writeEmptyElement(name={}) - start", name);

        writeElement(name);
        return endElement();
    }

    /**
     * Begin to write out an element. Unlike the helper tags, this tag will need
     * to be ended with the endElement method.
     *
     * @param name
     *            String name of tag
     */
    public XmlWriter writeElement(final String name) throws IOException
    {
        logger.debug("writeElement(name={}) - start", name);

        return openElement(name);
    }

    /**
     * Begin to output an element.
     *
     * @param name
     *            name of element.
     */
    private XmlWriter openElement(final String name) throws IOException
    {
        logger.debug("openElement(name={}) - start", name);

        final boolean wasClosed = this.closed;
        closeOpeningTag();
        this.closed = false;
        if (this.pretty)
        {
            // ! wasClosed separates adjacent opening tags by a newline.
            // this.wroteText makes sure an element embedded within the text of
            // its parent element begins on a new line, indented to the proper
            // level. This solves only part of the problem of pretty printing
            // entities which contain both text and child entities.
            if (!wasClosed || this.wroteText)
            {
                this.out.write(newline);
            }
            for (int i = 0; i < this.stack.size(); i++)
            {
                this.out.write(indent); // Indent opening tag to proper level
            }
        }
        this.out.write("<");
        this.out.write(name);
        this.stack.push(name);
        this.empty = true;
        this.wroteText = false;
        return this;
    }

    /** Close off the opening tag. **/
    private void closeOpeningTag() throws IOException
    {
        logger.debug("closeOpeningTag() - start");

        if (!this.closed)
        {
            writeAttributes();
            this.closed = true;
            this.out.write(">");
        }
    }

    /** Write out all current attributes. */
    private void writeAttributes() throws IOException
    {
        logger.debug("writeAttributes() - start");

        if (this.attrs != null)
        {
            this.out.write(this.attrs.toString());
            this.attrs.setLength(0);
            this.empty = false;
        }
    }

    /**
     * Write an attribute out for the current element. Any XML characters in the
     * value are escaped. Currently it does not actually throw the exception,
     * but the API is set that way for future changes.
     *
     * @param attr
     *            name of attribute.
     * @param value
     *            value of attribute.
     * @see #writeAttribute(String, String, boolean)
     */
    public XmlWriter writeAttribute(final String attr, final String value)
            throws IOException
    {
        logger.debug("writeAttribute(attr={}, value={}) - start", attr, value);
        return this.writeAttribute(attr, value, false);
    }

    /**
     * Write an attribute out for the current element. Any XML characters in the
     * value are escaped. Currently it does not actually throw the exception,
     * but the API is set that way for future changes.
     *
     * @param attr
     *            name of attribute.
     * @param value
     *            value of attribute.
     * @param literally
     *            If the writer should be literally on the given value which
     *            means that meta characters will also be preserved by escaping
     *            them. Mainly preserves newlines and tabs.
     */
    public XmlWriter writeAttribute(final String attr, final String value,
            final boolean literally) throws IOException
    {
        if (logger.isDebugEnabled())
        {
            logger.debug(
                    "writeAttribute(attr={}, value={}, literally={}) - start",
                    new Object[] {attr, value, String.valueOf(literally)});
        }

        if (this.wroteText == true)
        {
            throw new IllegalStateException(
                    "The text for the current element has already been written. Cannot add attributes afterwards.");
        }
        // maintain API
        if (false)
        {
            throw new IOException();
        }

        if (this.attrs == null)
        {
            this.attrs = new StringBuilder();
        }
        this.attrs.append(" ");
        this.attrs.append(attr);
        this.attrs.append("=\"");
        this.attrs.append(escapeXml(value, literally));
        this.attrs.append("\"");
        return this;
    }

    /**
     * End the current element. This will throw an exception if it is called
     * when there is not a currently open element.
     */
    public XmlWriter endElement() throws IOException
    {
        logger.debug("endElement() - start");

        if (this.stack.isEmpty())
        {
            throw new IOException("Called endElement too many times. ");
        }
        final String name = this.stack.pop();
        if (name != null)
        {
            if (this.empty)
            {
                writeAttributes();
                this.out.write("/>");
            } else
            {
                if (this.pretty && !this.wroteText)
                {
                    for (int i = 0; i < this.stack.size(); i++)
                    {
                        this.out.write(indent); // Indent closing tag to proper
                                                // level
                    }
                }
                this.out.write("</");
                this.out.write(name);
                this.out.write(">");
            }
            if (this.pretty)
            {
                this.out.write(newline); // Add a newline after the closing tag
            }
            this.empty = false;
            this.closed = true;
            this.wroteText = false;
        }
        return this;
    }

    /**
     * Close this writer. It does not close the underlying writer, but does
     * throw an exception if there are as yet unclosed tags.
     */
    public void close() throws IOException
    {
        logger.debug("close() - start");

        this.out.flush();

        if (!this.stack.isEmpty())
        {
            throw new IOException("Tags are not all closed. " + "Possibly, "
                    + this.stack.pop() + " is unclosed. ");
        }
    }

    /**
     * Output body text. Any XML characters are escaped.
     *
     * @param text
     *            The text to be written
     * @return This writer
     * @throws IOException
     * @see #writeText(String, boolean)
     */
    public XmlWriter writeText(final String text) throws IOException
    {
        logger.debug("writeText(text={}) - start", text);
        return this.writeText(text, false);
    }

    /**
     * Output body text. Any XML characters are escaped.
     *
     * @param text
     *            The text to be written
     * @param literally
     *            If the writer should be literally on the given value which
     *            means that meta characters will also be preserved by escaping
     *            them. Mainly preserves newlines and tabs.
     * @return This writer
     * @throws IOException
     */
    public XmlWriter writeText(final String text, final boolean literally)
            throws IOException
    {
        if (logger.isDebugEnabled())
        {
            logger.debug("writeText(text={}, literally={}) - start", text,
                    String.valueOf(literally));
        }

        closeOpeningTag();
        this.empty = false;
        this.wroteText = true;

        this.out.write(escapeXml(text, literally));
        return this;
    }

    /**
     * Write out a chunk of CDATA. This helper method surrounds the passed in
     * data with the CDATA tag.
     *
     * @param cdata
     *            of CDATA text.
     */
    public XmlWriter writeCData(String cdata) throws IOException
    {
        logger.debug("writeCData(cdata={}) - start", cdata);

        closeOpeningTag();

        final boolean hasAlreadyEnclosingCdata =
                cdata.startsWith(CDATA_START) && cdata.endsWith(CDATA_END);

        // There may already be CDATA sections inside the data.
        // But CDATA sections can't be nested - can't have ]]> inside a CDATA
        // section.
        // (See http://www.w3.org/TR/REC-xml/#NT-CDStart in the W3C specs)
        // The solutions is to replace any occurrence of "]]>" by
        // "]]]]><![CDATA[>",
        // so that the top CDATA section is split into many valid CDATA sections
        // (you
        // can look at the "]]]]>" as if it was an escape sequence for "]]>").
        if (!hasAlreadyEnclosingCdata)
        {
            cdata = cdata.replaceAll(CDATA_END, "]]]]><![CDATA[>");
        }

        this.empty = false;
        this.wroteText = true;
        if (!hasAlreadyEnclosingCdata)
        {
            this.out.write(CDATA_START);
        }
        this.out.write(cdata);
        if (!hasAlreadyEnclosingCdata)
        {
            this.out.write(CDATA_END);
        }
        return this;
    }

    /**
     * Write out a chunk of comment. This helper method surrounds the passed in
     * data with the XML comment tag.
     *
     * @param comment
     *            of text to comment.
     */
    public XmlWriter writeComment(final String comment) throws IOException
    {
        logger.debug("writeComment(comment={}) - start", comment);

        writeChunk("<!-- " + comment + " -->");
        return this;
    }

    ////////////////////////////////////////////////////////////////////////////
    // Added for DbUnit

    private void writeChunk(final String data) throws IOException
    {
        logger.debug("writeChunk(data={}) - start", data);

        closeOpeningTag();
        this.empty = false;
        if (this.pretty && !this.wroteText)
        {
            for (int i = 0; i < this.stack.size(); i++)
            {
                this.out.write(indent);
            }
        }

        this.out.write(data);

        if (this.pretty)
        {
            this.out.write(newline);
        }
    }

    // Two example methods. They should output the same XML:
    // <person name="fred" age="12"><phone>425343</phone><bob/></person>
    static public void main(final String[] args) throws IOException
    {
        logger.debug("main(args={}) - start", args);

        test1();
        test2();
    }

    static public void test1() throws IOException
    {
        logger.debug("test1() - start");

        final Writer writer = new java.io.StringWriter();
        final XmlWriter xmlwriter = new XmlWriter(writer);
        xmlwriter.writeElement("person").writeAttribute("name", "fred")
                .writeAttribute("age", "12").writeElement("phone")
                .writeText("4254343").endElement().writeElement("friends")
                .writeElement("bob").endElement().writeElement("jim")
                .endElement().endElement().endElement();
        xmlwriter.close();
        System.err.println(writer.toString());
    }

    static public void test2() throws IOException
    {
        logger.debug("test2() - start");

        final Writer writer = new java.io.StringWriter();
        final XmlWriter xmlwriter = new XmlWriter(writer);
        xmlwriter.writeComment("Example of XmlWriter running");
        xmlwriter.writeElement("person");
        xmlwriter.writeAttribute("name", "fred");
        xmlwriter.writeAttribute("age", "12");
        xmlwriter.writeElement("phone");
        xmlwriter.writeText("4254343");
        xmlwriter.endElement();
        xmlwriter.writeComment("Examples of empty tags");
        // xmlwriter.setDefaultNamespace("test");
        xmlwriter.writeElement("friends");
        xmlwriter.writeEmptyElement("bob");
        xmlwriter.writeEmptyElement("jim");
        xmlwriter.endElement();
        xmlwriter.writeElementWithText("foo", "This is an example.");
        xmlwriter.endElement();
        xmlwriter.close();
        System.err.println(writer.toString());
    }

    ////////////////////////////////////////////////////////////////////////////
    // Added for DbUnit

    /**
     * Escapes some meta characters like \n, \r that should be preserved in the
     * XML so that a reader will not filter out those symbols. This code is
     * modified from xmlrpc:
     * https://svn.apache.org/repos/asf/webservices/xmlrpc/branches/
     * XMLRPC_1_2_BRANCH/src/java/org/apache/xmlrpc/XmlWriter.java
     *
     * @param str
     *            The string to be escaped
     * @param literally
     *            If the writer should be literally on the given value which
     *            means that meta characters will also be preserved by escaping
     *            them. Mainly preserves newlines and carriage returns.
     * @return The escaped string
     */
    private String escapeXml(final String str, final boolean literally)
    {
        logger.debug("escapeXml(str={}, literally={}) - start", str,
                Boolean.toString(literally));

        char[] block = null;
        int last = 0;
        StringBuilder buffer = null;
        final int strLength = str.length();
        int index = 0;

        for (index = 0; index < strLength; index++)
        {
            final char currentChar = str.charAt(index);
            final String entity =
                    convertCharacterToEntity(currentChar, literally);

            // If we found something to substitute, then copy over previous
            // data then do the substitution.
            if (entity != null)
            {
                if (block == null)
                {
                    block = str.toCharArray();
                }
                if (buffer == null)
                {
                    buffer = new StringBuilder();
                }
                buffer.append(block, last, index - last);
                buffer.append(entity);
                last = index + 1;
            }
        }

        // nothing found, just return source
        if (last == 0)
        {
            return str;
        }

        if (last < strLength)
        {
            if (block == null)
            {
                block = str.toCharArray();
            }
            if (buffer == null)
            {
                buffer = new StringBuilder();
            }
            buffer.append(block, last, index - last);
        }

        return buffer.toString();
    }

    protected String convertCharacterToEntity(final char currentChar,
            final boolean literally)
    {
        String entity = null;
        switch (currentChar)
        {
        case '\t':
            entity = "&#09;";
            break;
        case '\n':
            if (literally)
            {
                entity = "&#xA;";
            }
            break;
        case '\r':
            if (literally)
            {
                entity = "&#xD;";
            }
            break;
        case '&':
            entity = "&amp;";
            break;
        case '<':
            entity = "&lt;";
            break;
        case '>':
            entity = "&gt;";
            break;
        case '\"':
            entity = "&quot;";
            break;
        case '\'':
            entity = "&apos;";
            break;
        default:
            if ((currentChar > 0x7f) && !isValidXmlChar(currentChar))
            {
                entity = "&#" + String.valueOf((int) currentChar) + ";";
            }
            break;
        }
        return entity;
    }

    /**
     * Section 2.2 of the XML spec describes which Unicode code points are valid
     * in XML:
     *
     * <blockquote><code>#x9 | #xA | #xD | [#x20-#xD7FF] |
     * [#xE000-#xFFFD] | [#x10000-#x10FFFF]</code></blockquote>
     *
     * Code points outside this set must be entity encoded to be represented in
     * XML.
     *
     * @param c The character to inspect. Type is int because unicode char value may exceed Character.MAX_VALUE.
     * @return Whether the specified character is valid in XML.
     */
    private static boolean isValidXmlChar(int c)
    {
        switch (c)
        {
        case 0x9:
        case 0xa: // line feed, '\n'
        case 0xd: // carriage return, '\r'
            return true;

        default:
            return ((0x20 <= c && c <= 0xd7ff) || (0xe000 <= c && c <= 0xfffd)
                    || (0x10000 <= c && c <= 0x10ffff));
        }
    }

    private String replace(final String value, final String original,
            final String replacement)
    {
        if (logger.isDebugEnabled())
        {
            logger.debug("replace(value=" + value + ", original=" + original
                    + ", replacement=" + replacement + ") - start");
        }

        StringBuilder buffer = null;

        int startIndex = 0;
        int lastEndIndex = 0;
        for (;;)
        {
            startIndex = value.indexOf(original, lastEndIndex);
            if (startIndex == -1)
            {
                if (buffer != null)
                {
                    buffer.append(value.substring(lastEndIndex));
                }
                break;
            }

            if (buffer == null)
            {
                buffer = new StringBuilder((int) (original.length() * 1.5));
            }
            buffer.append(value.substring(lastEndIndex, startIndex));
            buffer.append(replacement);
            lastEndIndex = startIndex + original.length();
        }

        return buffer == null ? value : buffer.toString();
    }

    private void setEncoding(String encoding)
    {
        logger.debug("setEncoding(encoding={}) - start", encoding);

        Charset charset = null;

        if (encoding == null && out instanceof OutputStreamWriter)
        {
            charset = Charset.forName(((OutputStreamWriter) out).getEncoding());
        }

        if (encoding != null)
        {
            final String ucEncoding = encoding.toUpperCase();

            // Use official encoding names where we know them,
            // avoiding the Java-only names. When using common
            // encodings where we can easily tell if characters
            // are out of range, we'll escape out-of-range
            // characters using character refs for safety.

            // I _think_ these are all the main synonyms for these!
            if ("UTF8".equalsIgnoreCase(ucEncoding))
            {
                charset = StandardCharsets.UTF_8;
            } else if ("US-ASCII".equalsIgnoreCase(ucEncoding) || "ASCII".equalsIgnoreCase(ucEncoding))
            {
                // dangerMask = (short)0xff80;
                charset = StandardCharsets.US_ASCII;
            } else if ("ISO-8859-1".equalsIgnoreCase(ucEncoding)
                    || "8859_1".equalsIgnoreCase(ucEncoding)
                    || "ISO8859_1".equalsIgnoreCase(ucEncoding))
            {
                // dangerMask = (short)0xff00;
                charset = StandardCharsets.ISO_8859_1;
            } else if ("UNICODE".equalsIgnoreCase(ucEncoding)
                    || "UNICODE-BIG".equalsIgnoreCase(ucEncoding)
                    || "UNICODE-LITTLE".equalsIgnoreCase(ucEncoding))
            {
                charset = StandardCharsets.UTF_16;

                // TODO: UTF-16BE, UTF-16LE ... no BOM; what
                // release of JDK supports those Unicode names?
            }

            // if (dangerMask != 0)
            // stringBuf = new StringBuffer();
        }

        setEncoding(charset);
    }

    private void setEncoding(Charset charset)
    {
        this.encoding = charset;
    }

    /**
     * Resets the handler to write a new text document.
     *
     * @param writer
     *            XML text is written to this writer.
     * @param encoding
     *            if non-null, and an XML declaration is written, this is the
     *            name that will be used for the character encoding.
     *
     * @exception IllegalStateException
     *                if the current document hasn't yet ended (i.e. the output
     *                stream {@link #out} is not null)
     */
    final public void setWriter(final Writer writer, final String encoding)
    {
        logger.debug("setWriter(writer={}, encoding={}) - start", writer,
                encoding);

        setWriter(writer, Charset.forName(encoding));
    }

    final public void setWriter(final Writer writer, final Charset charset)
    {
        logger.debug("setWriter(writer={}, charset={}) - start", writer,
                charset);

        if (this.out != null)
        {
            throw new IllegalStateException(
                    "can't change stream in mid course");
        }
        this.out = writer;
        if (this.out != null)
        {
            setEncoding(charset);
            // if (!(this.out instanceof BufferedWriter))
            // this.out = new BufferedWriter(this.out);
        }
    }

    public XmlWriter writeDeclaration() throws IOException
    {
        logger.debug("writeDeclaration() - start");

        if (this.encoding != null)
        {
            this.out.write("<?xml version='1.0'");
            this.out.write(" encoding='" + this.encoding + "'");
            this.out.write("?>");
            this.out.write(this.newline);
        }

        return this;
    }

    public XmlWriter writeDoctype(final String systemId, final String publicId)
            throws IOException
    {
        logger.debug("writeDoctype(systemId={}, publicId={}) - start", systemId,
                publicId);

        if (systemId != null || publicId != null)
        {
            this.out.write("<!DOCTYPE dataset");

            if (systemId != null)
            {
                this.out.write(" SYSTEM \"");
                this.out.write(systemId);
                this.out.write("\"");
            }

            if (publicId != null)
            {
                this.out.write(" PUBLIC \"");
                this.out.write(publicId);
                this.out.write("\"");
            }

            this.out.write(">");
            this.out.write(this.newline);
        }

        return this;
    }
}