Java tutorial
/** * 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 = "<"; protected static final String GREATER_THAN_ENTITY = ">"; protected static final String AMPERSAND_ENTITY = "&"; 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 "&#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; } }