fr.dutra.confluence2wordpress.xmlrpc.XmlWriter.java Source code

Java tutorial

Introduction

Here is the source code for fr.dutra.confluence2wordpress.xmlrpc.XmlWriter.java

Source

/**
 * Copyright 2011-2012 Alexandre Dutra
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package fr.dutra.confluence2wordpress.xmlrpc;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;

import org.apache.commons.codec.EncoderException;
import org.apache.commons.codec.binary.Base64;
import org.apache.xmlrpc.DefaultTypeDecoder;
import org.apache.xmlrpc.TypeDecoder;
import org.apache.xmlrpc.XmlRpcException;
import org.apache.xmlrpc.util.DateTool;

/**
 * This is a copy of the original XmlWriter from Apache XmlRpc.
 * The main purpose is to get rid of the Base64 multi-threading issue.
 * @see "https://issues.apache.org/jira/browse/CODEC-96"
 */
public class XmlWriter extends OutputStreamWriter {
    // Various XML pieces.
    protected static final String PROLOG_START = "<?xml version=\"1.0";
    protected static final String PROLOG_END = "\"?>";
    protected static final String CLOSING_TAG_START = "</";
    protected static final String SINGLE_TAG_END = "/>";
    protected static final String LESS_THAN_ENTITY = "&lt;";
    protected static final String GREATER_THAN_ENTITY = "&gt;";
    protected static final String AMPERSAND_ENTITY = "&amp;";

    private static final char[] PROLOG = new char[PROLOG_START.length() + PROLOG_END.length()];
    static {
        int len = PROLOG_START.length();
        PROLOG_START.getChars(0, len, PROLOG, 0);
        PROLOG_END.getChars(0, PROLOG_END.length(), PROLOG, len);
    }

    /**
     * Java's name for the ISO-8859-1 encoding.
     */
    static final String ISO8859_1 = "ISO8859_1";

    /**
     * Java's name for the UTF-8 encoding.
     */
    static final String UTF8 = "UTF8";

    /**
     * Java's name for the UTF-16 encoding.
     */
    static final String UTF16 = "UTF-16";

    //Base64 instances are NOT thread safe and should not be static
    //https://issues.apache.org/jira/browse/CODEC-96
    protected /*static*/ final Base64 base64Codec = new Base64();

    /**
     * Class to delegate type decoding to.
     */
    protected static TypeDecoder typeDecoder;

    /**
     * Mapping between Java encoding names and "real" names used in
     * XML prolog.
     *
     * @see <a href="http://java.sun.com/j2se/1.4.2/docs/guide/intl/encoding.doc.html">Java character set names</a>
     */
    private static Properties encodings = new Properties();

    static {
        encodings.put(UTF8, "UTF-8");
        encodings.put(ISO8859_1, "ISO-8859-1");
        typeDecoder = new DefaultTypeDecoder();
    }

    /**
     * Thread-safe wrapper for the <code>DateFormat</code> object used
     * to parse date/time values.
     */
    DateTool dateTool = new DateTool();

    /**
     * Whether the XML prolog has been written.
     */
    boolean hasWrittenProlog = false;

    /**
     * Creates a new instance.
     *
     * @param out The stream to write output to.
     * @param enc The encoding to using for outputting XML.  Only UTF-8
     * and UTF-16 are supported.  If another encoding is specified,
     * UTF-8 will be used instead for widest XML parser
     * interoperability.
     * @exception UnsupportedEncodingException Since unsupported
     * encodings are internally converted to UTF-8, this should only
     * be seen as the result of an internal error.
     */
    public XmlWriter(OutputStream out, String enc) throws UnsupportedEncodingException {
        // Super-class wants the Java form of the encoding.
        super(out, forceUnicode(enc));
    }

    /**
     * @param encoding A caller-specified encoding.
     * @return An Unicode encoding.
     */
    private static String forceUnicode(String encoding) {
        if (encoding == null || !encoding.toUpperCase().startsWith("UTF")) {
            encoding = UTF8;
        }
        return encoding;
    }

    /**
     * Tranforms a Java encoding to the canonical XML form (if a
     * mapping is available).
     *
     * @param javaEncoding The name of the encoding as known by Java.
     * @return The XML encoding (if a mapping is available);
     * otherwise, the encoding as provided.
     *
     * @deprecated This method will not be visible in 2.0.
     */
    protected static String canonicalizeEncoding(String javaEncoding) {
        return encodings.getProperty(javaEncoding, javaEncoding);
    }

    /**
     * A mostly pass-through implementation wrapping
     * <code>OutputStreamWriter.write()</code> which assures that the
     * XML prolog is written before any other data.
     *
     * @see java.io.OutputStreamWriter.write(char[], int, int)
     */
    public void write(char[] cbuf, int off, int len) throws IOException {
        if (!hasWrittenProlog) {
            super.write(PROLOG, 0, PROLOG.length);
            hasWrittenProlog = true;
        }
        super.write(cbuf, off, len);
    }

    /**
     * A mostly pass-through implementation wrapping
     * <code>OutputStreamWriter.write()</code> which assures that the
     * XML prolog is written before any other data.
     *
     * @see java.io.OutputStreamWriter.write(char)
     */
    public void write(char c) throws IOException {
        if (!hasWrittenProlog) {
            super.write(PROLOG, 0, PROLOG.length);
            hasWrittenProlog = true;
        }
        super.write(c);
    }

    /**
     * A mostly pass-through implementation wrapping
     * <code>OutputStreamWriter.write()</code> which assures that the
     * XML prolog is written before any other data.
     *
     * @see java.io.OutputStreamWriter.write(String, int, int)
     */
    public void write(String str, int off, int len) throws IOException {
        if (!hasWrittenProlog) {
            super.write(PROLOG, 0, PROLOG.length);
            hasWrittenProlog = true;
        }
        super.write(str, off, len);
    }

    /**
     * Writes the XML representation of a supported Java object type.
     *
     * @param obj The <code>Object</code> to write.
     * @exception XmlRpcException Unsupported character data found.
     * @exception IOException Problem writing data.
     * @throws IllegalArgumentException If a <code>null</code>
     * parameter is passed to this method (not supported by the <a
     * href="http://xml-rpc.com/spec">XML-RPC specification</a>).
     */
    public void writeObject(Object obj) throws XmlRpcException, IOException {
        startElement("value");
        if (obj == null) {
            throw new XmlRpcException(0, "null values not supported by XML-RPC");
        } else if (obj instanceof String) {
            chardata(obj.toString());
        } else if (typeDecoder.isXmlRpcI4(obj)) {
            startElement("int");
            write(obj.toString());
            endElement("int");
        } else if (obj instanceof Boolean) {
            startElement("boolean");
            write(((Boolean) obj).booleanValue() ? "1" : "0");
            endElement("boolean");
        } else if (typeDecoder.isXmlRpcDouble(obj)) {
            startElement("double");
            write(obj.toString());
            endElement("double");
        } else if (obj instanceof Date) {
            startElement("dateTime.iso8601");
            Date d = (Date) obj;
            write(dateTool.format(d));
            endElement("dateTime.iso8601");
        } else if (obj instanceof byte[]) {
            startElement("base64");
            try {
                this.write((byte[]) base64Codec.encode(obj));
            } catch (EncoderException e) {
                throw new XmlRpcException(0, "Unable to Base 64 encode byte array", e);
            }
            endElement("base64");
        } else if (obj instanceof Object[]) {
            startElement("array");
            startElement("data");
            Object[] array = (Object[]) obj;
            for (int i = 0; i < array.length; i++) {
                writeObject(array[i]);
            }
            endElement("data");
            endElement("array");
        } else if (obj instanceof List<?>) {
            startElement("array");
            startElement("data");
            List<?> list = (List<?>) obj;
            int size = list.size();
            for (int i = 0; i < size; i++) {
                writeObject(list.get(i));
            }
            endElement("data");
            endElement("array");
        } else if (obj instanceof Map<?, ?>) {
            startElement("struct");
            Map<?, ?> struct = (Map<?, ?>) obj;
            for (Entry<?, ?> entry : struct.entrySet()) {
                String key = (String) entry.getKey();
                Object value = entry.getValue();
                startElement("member");
                startElement("name");
                chardata(key);
                endElement("name");
                writeObject(value);
                endElement("member");
            }
            endElement("struct");
        } else {
            throw new XmlRpcException(0, "Unsupported Java type: " + obj.getClass(), null);
        }
        endElement("value");
    }

    /**
     * This is used to write out the Base64 output...
     */
    protected void write(byte[] byteData) throws IOException {
        for (int i = 0; i < byteData.length; i++) {
            write(byteData[i]);
        }
    }

    /**
     * Writes characters like '\r' (0xd) as "&amp;#13;".
     */
    private void writeCharacterReference(char c) throws IOException {
        write("&#");
        write(String.valueOf((int) c));
        write(';');
    }

    /**
     *
     * @param elem
     * @throws IOException
     */
    protected void startElement(String elem) throws IOException {
        write('<');
        write(elem);
        write('>');
    }

    /**
     *
     * @param elem
     * @throws IOException
     */
    protected void endElement(String elem) throws IOException {
        write(CLOSING_TAG_START);
        write(elem);
        write('>');
    }

    /**
     *
     * @param elem
     * @throws IOException
     */
    protected void emptyElement(String elem) throws IOException {
        write('<');
        write(elem);
        write(SINGLE_TAG_END);
    }

    /**
     * Writes text as <code>PCDATA</code>.
     *
     * @param text The data to write.
     * @exception XmlRpcException Unsupported character data found.
     * @exception IOException Problem writing data.
     */
    protected void chardata(String text) throws XmlRpcException, IOException {
        int l = text.length();
        // ### TODO: Use a buffer rather than going character by
        // ### character to scale better for large text sizes.
        //char[] buf = new char[32];
        for (int i = 0; i < l; i++) {
            char c = text.charAt(i);
            switch (c) {
            case '\t':
            case '\n':
                write(c);
                break;
            case '\r':
                // Avoid normalization of CR to LF.
                writeCharacterReference(c);
                break;
            case '<':
                write(LESS_THAN_ENTITY);
                break;
            case '>':
                write(GREATER_THAN_ENTITY);
                break;
            case '&':
                write(AMPERSAND_ENTITY);
                break;
            default:
                // Though the XML spec requires XML parsers to support
                // Unicode, not all such code points are valid in XML
                // documents.  Additionally, previous to 2003-06-30
                // the XML-RPC spec only allowed ASCII data (in
                // <string> elements).  For interoperability with
                // clients rigidly conforming to the pre-2003 version
                // of the XML-RPC spec, we entity encode characters
                // outside of the valid range for ASCII, too.
                if (c > 0x7f || !isValidXMLChar(c)) {
                    // Replace the code point with a character reference.
                    writeCharacterReference(c);
                } else {
                    write(c);
                }
            }
        }
    }

    /**
     * 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.
     * @return Whether the specified character is valid in XML.
     */
    private static final boolean isValidXMLChar(char 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));
        }
    }

    protected static void setTypeDecoder(TypeDecoder newTypeDecoder) {
        typeDecoder = newTypeDecoder;
    }
}