Support charsets other than UTF-8

Author: reline

core/src/main/java/com/tickaroo/tikxml/TikXml.java

@@ -21,6 +21,8 @@
 import com.tickaroo.tikxml.typeadapter.TypeAdapter;
 import java.io.IOException;
 import java.lang.reflect.Type;
+import java.nio.charset.Charset;
+
 import okio.BufferedSink;
 import okio.BufferedSource;
 
@@ -64,6 +66,17 @@ public Builder writeDefaultXmlDeclaration(boolean writeDeclaration) {
       return this;
     }
 
+    /**
+     * Specify the charset
+     *
+     * @param charset character encoding set to use when reading and writing the xml document
+     * @return The Builder itself
+     */
+    public Builder charset(Charset charset) {
+      config.charset = charset;
+      return this;
+    }
+
     /**
      * Adds an type converter for the given class
      *
@@ -105,7 +118,7 @@ private TikXml(TikXmlConfig config) {
 
   public <T> T read(BufferedSource source, Type clazz) throws IOException {
 
-    XmlReader reader = XmlReader.of(source);
+    XmlReader reader = XmlReader.of(source, config.charset);
 
     reader.beginElement();
     reader.nextElementName(); // We don't care about the name of the root tag
@@ -125,7 +138,7 @@ public <T> void write(BufferedSink sink, T valueToWrite) throws IOException {
 
   public <T> void write(BufferedSink sink, T valueToWrite, Type typeOfValueToWrite) throws IOException {
 
-    XmlWriter writer = XmlWriter.of(sink);
+    XmlWriter writer = XmlWriter.of(sink, config.charset);
 
     TypeAdapter<T> adapter = config.getTypeAdapter(typeOfValueToWrite);
     if (config.writeDefaultXmlDeclaration()) {

core/src/main/java/com/tickaroo/tikxml/TikXmlConfig.java

@@ -21,6 +21,8 @@
 import com.tickaroo.tikxml.typeadapter.TypeAdapter;
 
 import java.lang.reflect.Type;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 
 /**
  * Holds the config for parsing and writing xml via {@link TikXml}
@@ -34,6 +36,7 @@ public final class TikXmlConfig {
   TypeConverters typeConverters = new TypeConverters();
   TypeAdapters typeAdapters = new TypeAdapters();
   boolean writeDefaultXmlDeclaration = true;
+  Charset charset = StandardCharsets.UTF_8;
 
   TikXmlConfig() {
   }
@@ -58,6 +61,15 @@ public boolean writeDefaultXmlDeclaration() {
     return writeDefaultXmlDeclaration;
   }
 
+  /**
+   * The charset
+   *
+   * @return character encoding set to use when reading and writing the xml document
+   */
+  public Charset charset() {
+    return charset;
+  }
+
   /**
    * Query a {@link TypeConverter} for a given class
    *

core/src/main/java/com/tickaroo/tikxml/XmlReader.java

@@ -26,6 +26,8 @@
 import java.io.Closeable;
 import java.io.EOFException;
 import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 
 /**
  * A class to read and parse an xml stream.
@@ -37,14 +39,13 @@ public class XmlReader implements Closeable {
 
   //private static final ByteString LINEFEED_OR_CARRIAGE_RETURN = ByteString.encodeUtf8("\n\r");
 
-  private static final ByteString UNQUOTED_STRING_TERMINALS
-      = ByteString.encodeUtf8(" >/=\n");
+  private final ByteString UNQUOTED_STRING_TERMINALS;
 
-  private static final ByteString CDATA_CLOSE = ByteString.encodeUtf8("]]>");
-  private static final ByteString CDATA_OPEN = ByteString.encodeUtf8("<![CDATA[");
-  private static final ByteString DOCTYPE_OPEN = ByteString.encodeUtf8("<!DOCTYPE");
-  private static final ByteString COMMENT_CLOSE = ByteString.encodeUtf8("-->");
-  private static final ByteString XML_DECLARATION_CLOSE = ByteString.encodeUtf8("?>");
+  private final ByteString CDATA_CLOSE;
+  private final ByteString CDATA_OPEN;
+  private final ByteString DOCTYPE_OPEN;
+  private final ByteString COMMENT_CLOSE;
+  private final ByteString XML_DECLARATION_CLOSE;
   private static final ByteString UTF8_BOM = ByteString.of((byte) 0xEF, (byte) 0xBB, (byte) 0xBF);
 
   private static final byte DOUBLE_QUOTE = '"';
@@ -97,21 +98,33 @@ public class XmlReader implements Closeable {
 
   private final BufferedSource source;
   private final Buffer buffer;
+  private final Charset charset;
   private String currentElementName;
 
-  private XmlReader(BufferedSource source) {
+  private XmlReader(BufferedSource source, Charset charset) {
     if (source == null) {
       throw new NullPointerException("source == null");
     }
     this.source = source;
     this.buffer = source.buffer();
+    this.charset = charset;
+    UNQUOTED_STRING_TERMINALS = ByteString.encodeString(" >/=\n", charset);
+    CDATA_CLOSE = ByteString.encodeString("]]>", charset);
+    CDATA_OPEN = ByteString.encodeString("<![CDATA[", charset);
+    DOCTYPE_OPEN = ByteString.encodeString("<!DOCTYPE", charset);
+    COMMENT_CLOSE = ByteString.encodeString("-->", charset);
+    XML_DECLARATION_CLOSE = ByteString.encodeString("?>", charset);
   }
 
   /**
    * Returns a new instance that reads a XML-encoded stream from {@code source}.
    */
   public static XmlReader of(BufferedSource source) {
-    return new XmlReader(source);
+    return new XmlReader(source, StandardCharsets.UTF_8);
+  }
+
+  public static XmlReader of(BufferedSource source, Charset charset) {
+    return new XmlReader(source, charset);
   }
 
   /**
@@ -564,14 +577,14 @@ public String nextTextContent() throws IOException {
             + "> but haven't found");
       }
 
-      return buffer.readUtf8(index);
+      return buffer.readString(index, charset);
     } else if (p == PEEKED_CDATA) {
       peeked = PEEKED_NONE;
 
       // Search index of closing CDATA tag ]]>
       long index = indexOfClosingCDATA();
 
-      String result = buffer.readUtf8(index);
+      String result = buffer.readString(index, charset);
       buffer.skip(3); // consume ]]>
       return result;
     } else if (p == PEEKED_ELEMENT_END) {
@@ -897,7 +910,7 @@ public String getCurrentElementName() {
   /** Returns an unquoted value as a string. */
   private String nextUnquotedValue() throws IOException {
     long i = source.indexOfElement(UNQUOTED_STRING_TERMINALS);
-    return i != -1 ? buffer.readUtf8(i) : buffer.readUtf8();
+    return i != -1 ? buffer.readString(i, charset) : buffer.readString(charset);
   }
 
   /**
@@ -920,19 +933,19 @@ private String nextQuotedValue(byte runTerminator) throws IOException {
       // If we've got an escape character, we're going to need a string builder.
       if (buffer.getByte(index) == '\\') {
         if (builder == null) builder = new StringBuilder();
-        builder.append(buffer.readUtf8(index));
+        builder.append(buffer.readString(index, charset));
         buffer.readByte(); // '\'
         builder.append(readEscapeCharacter());
         continue;
       }
 
       // If it isn't the escape character, it's the quote. Return the string.
       if (builder == null) {
-        String result = buffer.readUtf8(index);
+        String result = buffer.readString(index, charset);
         buffer.readByte(); // Consume the quote character.
         return result;
       } else {
-        builder.append(buffer.readUtf8(index));
+        builder.append(buffer.readString(index, charset));
         buffer.readByte(); // Consume the quote character.
         return builder.toString();
       }
@@ -988,7 +1001,7 @@ private char readEscapeCharacter() throws IOException {
           } else if (c >= 'A' && c <= 'F') {
             result += (c - 'A' + 10);
           } else {
-            throw syntaxError("\\u" + buffer.readUtf8(4));
+            throw syntaxError("\\u" + buffer.readString(4, charset));
           }
         }
         buffer.skip(4);

core/src/main/java/com/tickaroo/tikxml/XmlWriter.java

@@ -18,15 +18,15 @@
 
 package com.tickaroo.tikxml;
 
-import java.io.Closeable;
-import java.io.IOException;
 import okio.BufferedSink;
 import okio.ByteString;
 
-import static com.tickaroo.tikxml.XmlScope.ELEMENT_CONTENT;
-import static com.tickaroo.tikxml.XmlScope.ELEMENT_OPENING;
-import static com.tickaroo.tikxml.XmlScope.NONEMPTY_DOCUMENT;
-import static com.tickaroo.tikxml.XmlScope.getTopStackElementAsToken;
+import java.io.Closeable;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+import static com.tickaroo.tikxml.XmlScope.*;
 
 /**
  * With this class you can write xml with a convinient API.
@@ -75,16 +75,16 @@ public class XmlWriter implements Closeable {
   private static final Byte DOUBLE_QUOTE = (byte) '"';
   private static final Byte OPENING_XML_ELEMENT = (byte) '<';
   private static final Byte CLOSING_XML_ELEMENT = (byte) '>';
-  private static final ByteString CLOSING_XML_ELEMENT_START = ByteString.encodeUtf8("</");
-  private static final ByteString INLINE_CLOSING_XML_ELEMENT = ByteString.encodeUtf8("/>");
-  private static final ByteString ATTRIBUTE_ASSIGNMENT_BEGIN = ByteString.encodeUtf8("=\"");
-  private static final ByteString OPENING_CDATA = ByteString.encodeUtf8("<![CDATA[");
-  private static final ByteString CLOSING_CDATA = ByteString.encodeUtf8("]]>");
-  private static final ByteString XML_DECLARATION =
-      ByteString.encodeUtf8("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+  private final ByteString CLOSING_XML_ELEMENT_START;
+  private final ByteString INLINE_CLOSING_XML_ELEMENT;
+  private final ByteString ATTRIBUTE_ASSIGNMENT_BEGIN;
+  private final ByteString OPENING_CDATA;
+  private final ByteString CLOSING_CDATA;
+  private final ByteString XML_DECLARATION;
 
   /** The output data, containing at most one top-level array or object. */
   private final BufferedSink sink;
+  private final Charset charset;
   private boolean xmlDeclarationWritten = false;
 
   private int[] stack = new int[32];
@@ -97,18 +97,30 @@ public class XmlWriter implements Closeable {
     stack[stackSize++] = XmlScope.EMPTY_DOCUMENT;
   }
 
-  private XmlWriter(BufferedSink sink) {
+  private XmlWriter(BufferedSink sink, Charset charset) {
     if (sink == null) {
       throw new NullPointerException("sink == null");
     }
     this.sink = sink;
+    this.charset = charset;
+
+    CLOSING_XML_ELEMENT_START = ByteString.encodeString("</", charset);
+    INLINE_CLOSING_XML_ELEMENT = ByteString.encodeString("/>", charset);
+    ATTRIBUTE_ASSIGNMENT_BEGIN = ByteString.encodeString("=\"", charset);
+    OPENING_CDATA = ByteString.encodeString("<![CDATA[", charset);
+    CLOSING_CDATA = ByteString.encodeString("]]>", charset);
+    XML_DECLARATION = ByteString.encodeString("<?xml version=\"1.0\" encoding=\"" + charset.name() + "\"?>", charset);
   }
 
   /**
    * Returns a new instance.
    */
   public static XmlWriter of(BufferedSink source) {
-    return new XmlWriter(source);
+    return new XmlWriter(source, StandardCharsets.UTF_8);
+  }
+
+  public static XmlWriter of(BufferedSink source, Charset charset) {
+    return new XmlWriter(source, charset);
   }
 
   private void pushStack(int newTop) {
@@ -190,14 +202,14 @@ public XmlWriter beginElement(String elementTagName) throws IOException {
         pushStack(XmlScope.ELEMENT_OPENING);
         pathNames[stackSize - 1] = elementTagName;
         sink.writeByte(OPENING_XML_ELEMENT)
-            .writeUtf8(elementTagName);
+            .writeString(elementTagName, charset);
         break;
 
       case XmlScope.ELEMENT_CONTENT: // write a nested xml element <parent> Some optional text <nested>
         pushStack(XmlScope.ELEMENT_OPENING);
         pathNames[stackSize - 1] = elementTagName;
         sink.writeByte(OPENING_XML_ELEMENT)
-            .writeUtf8(elementTagName);
+            .writeString(elementTagName, charset);
         break;
 
       case XmlScope.ELEMENT_OPENING: // write a nested xml element by closing the parent's xml opening header
@@ -206,7 +218,7 @@ public XmlWriter beginElement(String elementTagName) throws IOException {
         pathNames[stackSize - 1] = elementTagName;
         sink.writeByte(CLOSING_XML_ELEMENT)
             .writeByte(OPENING_XML_ELEMENT)
-            .writeUtf8(elementTagName);
+            .writeString(elementTagName, charset);
         break;
 
       case XmlScope.NONEMPTY_DOCUMENT:
@@ -239,7 +251,7 @@ public XmlWriter endElement() throws IOException {
         break;
       case XmlScope.ELEMENT_CONTENT:
         sink.write(CLOSING_XML_ELEMENT_START)
-            .writeUtf8(pathNames[stackSize - 1])
+            .writeString(pathNames[stackSize - 1], charset)
             .writeByte(CLOSING_XML_ELEMENT);
         popStack();
         break;
@@ -273,11 +285,11 @@ public XmlWriter textContent(String textContentValue) throws IOException {
       case ELEMENT_OPENING:
         sink.writeByte(CLOSING_XML_ELEMENT);
         replaceTopOfStack(XmlScope.ELEMENT_CONTENT);
-        sink.writeUtf8(textContentValue);
+        sink.writeString(textContentValue, charset);
         break;
 
       case ELEMENT_CONTENT:
-        sink.writeUtf8(textContentValue);
+        sink.writeString(textContentValue, charset);
         break;
 
       default:
@@ -346,13 +358,13 @@ public XmlWriter textContentAsCData(String textContentValue) throws IOException
         replaceTopOfStack(XmlScope.ELEMENT_CONTENT);
         sink.writeByte(CLOSING_XML_ELEMENT)
             .write(OPENING_CDATA)
-            .writeUtf8(textContentValue)
+            .writeString(textContentValue, charset)
             .write(CLOSING_CDATA);
         break;
 
       case ELEMENT_CONTENT:
         sink.write(OPENING_CDATA)
-            .writeUtf8(textContentValue)
+            .writeString(textContentValue, charset)
             .write(CLOSING_CDATA);
         break;
 
@@ -386,9 +398,9 @@ public XmlWriter textContentAsCData(String textContentValue) throws IOException
   public XmlWriter attribute(String attributeName, String value) throws IOException {
     if (XmlScope.ELEMENT_OPENING == peekStack()) {
       sink.writeByte(' ') // Write a whitespace
-          .writeUtf8(attributeName)
+          .writeString(attributeName, charset)
           .write(ATTRIBUTE_ASSIGNMENT_BEGIN)
-          .writeUtf8(value)
+          .writeString(value, charset)
           .writeByte(DOUBLE_QUOTE);
     } else {
       throw syntaxError("Error while trying to write attribute "
@@ -462,14 +474,14 @@ public XmlWriter xmlDeclaration() throws IOException {
         sink.write(XML_DECLARATION);
         xmlDeclarationWritten = true;
       } else {
-        throw syntaxError("Xml Declatraion "
-            + XML_DECLARATION.utf8()
+        throw syntaxError("Xml Declaration "
+            + XML_DECLARATION.string(charset)
             + " can only be written at the beginning of a xml document! You are not at the beginning of a xml document: current xml scope is "
             + XmlScope.getTopStackElementAsToken(stackSize, stack));
       }
     } else {
       throw new IOException("Xml declaration "
-          + XML_DECLARATION.utf8()
+          + XML_DECLARATION.string(charset)
           + " has already been written in this xml document. Xml declaration can only be written once at the beginning of the document.");
     }