Array support.

extras/src/main/java/com/google/gson/mini/ArrayTypeAdapter.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * 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 com.google.gson.mini;
+
+import com.google.gson.internal.$Gson$Types;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Adapt an array of objects.
+ */
+final class ArrayTypeAdapter<E> extends TypeAdapter<Object> {
+  public static final Factory FACTORY = new Factory() {
+    public <T> TypeAdapter<T> create(MiniGson context, TypeToken<T> typeToken) {
+      Type type = typeToken.getType();
+      if (!(type instanceof GenericArrayType || type instanceof Class && ((Class<?>) type).isArray())) {
+        return null;
+      }
+
+      Type componentType = $Gson$Types.getArrayComponentType(type);
+      TypeAdapter<?> componentTypeAdapter = context.getAdapter(TypeToken.get(componentType));
+      @SuppressWarnings("unchecked") // create() doesn't define a type parameter
+      TypeAdapter<T> result = new ArrayTypeAdapter(
+          componentTypeAdapter, $Gson$Types.getRawType(componentType));
+      return result;
+    }
+  };
+
+  private final Class<E> componentType;
+  private final TypeAdapter<E> componentTypeAdapter;
+
+  public ArrayTypeAdapter(TypeAdapter<E> componentTypeAdapter, Class<E> componentType) {
+    this.componentTypeAdapter = componentTypeAdapter;
+    this.componentType = componentType;
+  }
+
+  public Object read(JsonReader reader) throws IOException {
+    if (reader.peek() == JsonToken.NULL) {
+      reader.nextNull(); // TODO: does this belong here?
+      return null;
+    }
+
+    List<E> list = new ArrayList<E>();
+    reader.beginArray();
+    while (reader.hasNext()) {
+      E instance = componentTypeAdapter.read(reader);
+      list.add(instance);
+    }
+    reader.endArray();
+    Object array = Array.newInstance(componentType, list.size());
+    for (int i = 0; i < list.size(); i++) {
+      Array.set(array, i, list.get(i));
+    }
+    return array;
+  }
+
+  @Override public void write(JsonWriter writer, Object array) throws IOException {
+    if (array == null) {
+      writer.nullValue(); // TODO: better policy here?
+      return;
+    }
+
+    writer.beginArray();
+    for (int i = 0, length = Array.getLength(array); i < length; i++) {
+      final E value = (E) Array.get(array, i);
+      componentTypeAdapter.write(writer, value);
+    }
+    writer.endArray();
+  }
+}

extras/src/main/java/com/google/gson/mini/CollectionTypeAdapter.java

@@ -67,7 +67,7 @@ final class CollectionTypeAdapter<E> extends TypeAdapter<Collection<E>> {
         return null;
       }
 
-      @SuppressWarnings("unchecked") // we don't define a type parameter for the element type
+      @SuppressWarnings("unchecked") // create() doesn't define a type parameter
       TypeAdapter<T> result = new CollectionTypeAdapter(elementTypeAdapter, constructor);
       return result;
     }

extras/src/main/java/com/google/gson/mini/MiniGson.java

@@ -39,7 +39,8 @@ public final class MiniGson {
     factories.add(TypeAdapters.STRING_FACTORY);
     factories.add(ReflectiveTypeAdapter.FACTORY);
     factories.add(CollectionTypeAdapter.FACTORY);
-    factories.add(MapTypeAdapter.FACTORY);
+    factories.add(StringToValueMapTypeAdapter.FACTORY);
+    factories.add(ArrayTypeAdapter.FACTORY);
     this.factories = Collections.unmodifiableList(factories);
   }
 

extras/src/main/java/com/google/gson/mini/StringToValueMapTypeAdapter.java

@@ -29,9 +29,9 @@ import java.util.LinkedHashMap;
 import java.util.Map;
 
 /**
- * Adapt a homogeneous collection of objects.
+ * Adapt a map whose keys are strings.
  */
-final class MapTypeAdapter<V> extends TypeAdapter<Map<String, V>> {
+final class StringToValueMapTypeAdapter<V> extends TypeAdapter<Map<String, V>> {
   public static final Factory FACTORY = new Factory() {
     public <T> TypeAdapter<T> create(MiniGson context, TypeToken<T> typeToken) {
       Type type = typeToken.getType();
@@ -46,27 +46,20 @@ final class MapTypeAdapter<V> extends TypeAdapter<Map<String, V>> {
 
       Type[] keyAndValueTypes = $Gson$Types.getMapKeyAndValueTypes(type, rawType);
       if (keyAndValueTypes[0] != String.class) {
-        return null; // TODO: return an array-style map adapter
+        return null;
       }
       TypeAdapter<?> valueAdapter = context.getAdapter(TypeToken.get(keyAndValueTypes[1]));
 
-      Class<?> constructorType;
-
-      if (rawType == Map.class) {
-        constructorType = LinkedHashMap.class;
-      } else {
-        constructorType = rawType;
-      }
-
       Constructor<?> constructor;
       try {
+        Class<?> constructorType = (rawType == Map.class) ? LinkedHashMap.class : rawType;
         constructor = constructorType.getConstructor();
       } catch (NoSuchMethodException e) {
         return null;
       }
 
       @SuppressWarnings("unchecked") // we don't define a type parameter for the key or value types
-      TypeAdapter<T> result = new MapTypeAdapter(valueAdapter, constructor);
+      TypeAdapter<T> result = new StringToValueMapTypeAdapter(valueAdapter, constructor);
       return result;
     }
   };
@@ -74,7 +67,7 @@ final class MapTypeAdapter<V> extends TypeAdapter<Map<String, V>> {
   private final TypeAdapter<V> valueTypeAdapter;
   private final Constructor<? extends Map<String, V>> constructor;
 
-  public MapTypeAdapter(TypeAdapter<V> valueTypeAdapter,
+  public StringToValueMapTypeAdapter(TypeAdapter<V> valueTypeAdapter,
       Constructor<? extends Map<String, V>> constructor) {
     this.valueTypeAdapter = valueTypeAdapter;
     this.constructor = constructor;

extras/src/test/java/com/google/gson/mini/MiniGsonTest.java

@@ -118,6 +118,30 @@ public final class MiniGsonTest extends TestCase {
     assertEquals(map, mapAdapter.fromJson("{'a':5.0,'b':10.0}"));
   }
 
+  public void testSerialize1dArray() throws IOException {
+    TypeAdapter<double[]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[]>() {});
+    assertEquals("[1.0,2.0,3.0]", arrayAdapter.toJson(new double[]{1.0, 2.0, 3.0}));
+  }
+
+  public void testDeserialize1dArray() throws IOException {
+    TypeAdapter<double[]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[]>() {});
+    double[] array = arrayAdapter.fromJson("[1.0,2.0,3.0]");
+    assertTrue(Arrays.toString(array), Arrays.equals(new double[]{1.0, 2.0, 3.0}, array));
+  }
+
+  public void testSerialize2dArray() throws IOException {
+    TypeAdapter<double[][]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[][]>() {});
+    double[][] array = { {1.0, 2.0 }, { 3.0 } };
+    assertEquals("[[1.0,2.0],[3.0]]", arrayAdapter.toJson(array));
+  }
+
+  public void testDeserialize2dArray() throws IOException {
+    TypeAdapter<double[][]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[][]>() {});
+    double[][] array = arrayAdapter.fromJson("[[1.0,2.0],[3.0]]");
+    double[][] expected = { {1.0, 2.0 }, { 3.0 } };
+    assertTrue(Arrays.toString(array), Arrays.deepEquals(expected, array));
+  }
+
   static class Truck {
     double horsePower;
     List<Person> passengers = Collections.emptyList();