calabash-android 0.4.7.pre6 → 0.4.7.pre7

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ser/std/SerializableWithTypeSerializer.java

@@ -0,0 +1,90 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerationException;
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializableWithType;
+import sh.calaba.org.codehaus.jackson.map.ObjectMapper;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+import sh.calaba.org.codehaus.jackson.schema.JsonSerializableSchema;
+
+/**
+ * Generic handler for types that implement {@link JsonSerializableWithType}.
+ *<p>
+ * Note: given that this is used for anything that implements
+ * interface, can not be checked for direct class equivalence.
+ */
+@JacksonStdImpl
+public class SerializableWithTypeSerializer
+    extends SerializerBase<JsonSerializableWithType>
+{
+    public final static SerializableWithTypeSerializer instance = new SerializableWithTypeSerializer();
+
+    protected SerializableWithTypeSerializer() { super(JsonSerializableWithType.class); }
+
+    @SuppressWarnings("deprecation") // why is this needed?
+    @Override
+    public void serialize(JsonSerializableWithType value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        value.serialize(jgen, provider);
+    }
+
+    @Override
+    public final void serializeWithType(JsonSerializableWithType value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonGenerationException
+    {
+        value.serializeWithType(jgen, provider, typeSer);
+    }
+    
+    // copied verbatim from "JsonSerializableSerializer"
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        ObjectNode objectNode = createObjectNode();
+        String schemaType = "any";
+        String objectProperties = null;
+        String itemDefinition = null;
+        if (typeHint != null) {
+            Class<?> rawClass = TypeFactory.rawClass(typeHint);
+            if (rawClass.isAnnotationPresent(JsonSerializableSchema.class)) {
+                JsonSerializableSchema schemaInfo = rawClass.getAnnotation(JsonSerializableSchema.class);
+                schemaType = schemaInfo.schemaType();
+                if (!"##irrelevant".equals(schemaInfo.schemaObjectPropertiesDefinition())) {
+                    objectProperties = schemaInfo.schemaObjectPropertiesDefinition();
+                }
+                if (!"##irrelevant".equals(schemaInfo.schemaItemDefinition())) {
+                    itemDefinition = schemaInfo.schemaItemDefinition();
+                }
+            }
+        }
+        objectNode.put("type", schemaType);
+        if (objectProperties != null) {
+            try {
+                objectNode.put("properties", new ObjectMapper().readValue(objectProperties, JsonNode.class));
+            } catch (IOException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        if (itemDefinition != null) {
+            try {
+                objectNode.put("items", new ObjectMapper().readValue(itemDefinition, JsonNode.class));
+            } catch (IOException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        // always optional, no need to specify:
+        //objectNode.put("required", false);
+        return objectNode;
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ser/std/SerializerBase.java

@@ -0,0 +1,184 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Type;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerationException;
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.node.JsonNodeFactory;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+import sh.calaba.org.codehaus.jackson.schema.SchemaAware;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Base class used by all standard serializers. Provides some convenience
+ * methods for implementing {@link SchemaAware}
+ * 
+ * @since 1.9 (renamed from 'sh.calaba.org.codehaus.jackson.map.ser.SerializerBase')
+ */
+public abstract class SerializerBase<T>
+    extends JsonSerializer<T>
+    implements SchemaAware
+{
+    protected final Class<T> _handledType;
+    
+    protected SerializerBase(Class<T> t) {
+        _handledType = t;
+    }
+
+    /**
+     * @since 1.7
+     */
+    @SuppressWarnings("unchecked")
+    protected SerializerBase(JavaType type) {
+        _handledType = (Class<T>) type.getRawClass();
+    }
+    
+    /**
+     * Alternate constructor that is (alas!) needed to work
+     * around kinks of generic type handling
+     */
+    @SuppressWarnings("unchecked")
+    protected SerializerBase(Class<?> t, boolean dummy) {
+        _handledType = (Class<T>) t;
+    }
+
+    @Override
+    public final Class<T> handledType() { return _handledType; }
+    
+    @Override
+    public abstract void serialize(T value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException;
+
+    /**
+     * Note: since Jackson 1.9, default implementation claims type is "string"
+     */
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        return createSchemaNode("string");
+    }
+    
+    protected ObjectNode createObjectNode() {
+        return JsonNodeFactory.instance.objectNode();
+    }
+    
+    protected ObjectNode createSchemaNode(String type)
+    {
+        ObjectNode schema = createObjectNode();
+        schema.put("type", type);
+        return schema;
+    }
+    
+    protected ObjectNode createSchemaNode(String type, boolean isOptional)
+    {
+        ObjectNode schema = createSchemaNode(type);
+        // as per [JACKSON-563]. Note that 'required' defaults to false
+        if (!isOptional) {
+            schema.put("required", !isOptional);
+        }
+        return schema;
+    }
+
+    /**
+     * Method that can be called to determine if given serializer is the default
+     * serializer Jackson uses; as opposed to a custom serializer installed by
+     * a module or calling application. Determination is done using
+     * {@link JacksonStdImpl} annotation on serializer class.
+     * 
+     * @since 1.7
+     */
+    protected boolean isDefaultSerializer(JsonSerializer<?> serializer)
+    {
+        return (serializer != null && serializer.getClass().getAnnotation(JacksonStdImpl.class) != null);
+    }
+    
+    /**
+     * Method that will modify caught exception (passed in as argument)
+     * as necessary to include reference information, and to ensure it
+     * is a subtype of {@link IOException}, or an unchecked exception.
+     *<p>
+     * Rules for wrapping and unwrapping are bit complicated; essentially:
+     *<ul>
+     * <li>Errors are to be passed as is (if uncovered via unwrapping)
+     * <li>"Plain" IOExceptions (ones that are not of type
+     *   {@link JsonMappingException} are to be passed as is
+     *</ul>
+     */
+    public void wrapAndThrow(SerializerProvider provider,
+            Throwable t, Object bean, String fieldName)
+        throws IOException
+    {
+        /* 05-Mar-2009, tatu: But one nasty edge is when we get
+         *   StackOverflow: usually due to infinite loop. But that
+         *   usually gets hidden within an InvocationTargetException...
+         */
+        while (t instanceof InvocationTargetException && t.getCause() != null) {
+            t = t.getCause();
+        }
+        // Errors and "plain" IOExceptions to be passed as is
+        if (t instanceof Error) {
+            throw (Error) t;
+        }
+        // Ditto for IOExceptions... except for mapping exceptions!
+        boolean wrap = (provider == null) || provider.isEnabled(SerializationConfig.Feature.WRAP_EXCEPTIONS);
+        if (t instanceof IOException) {
+            if (!wrap || !(t instanceof JsonMappingException)) {
+                throw (IOException) t;
+            }
+        } else if (!wrap) { // [JACKSON-407] -- allow disabling wrapping for unchecked exceptions
+            if (t instanceof RuntimeException) {
+                throw (RuntimeException) t;
+            }
+        }
+        // [JACKSON-55] Need to add reference information
+        throw JsonMappingException.wrapWithPath(t, bean, fieldName);
+    }
+
+    public void wrapAndThrow(SerializerProvider provider,
+            Throwable t, Object bean, int index)
+        throws IOException
+    {
+        while (t instanceof InvocationTargetException && t.getCause() != null) {
+            t = t.getCause();
+        }
+        // Errors are to be passed as is
+        if (t instanceof Error) {
+            throw (Error) t;
+        }
+        // Ditto for IOExceptions... except for mapping exceptions!
+        boolean wrap = (provider == null) || provider.isEnabled(SerializationConfig.Feature.WRAP_EXCEPTIONS);
+        if (t instanceof IOException) {
+            if (!wrap || !(t instanceof JsonMappingException)) {
+                throw (IOException) t;
+            }
+        } else if (!wrap) { // [JACKSON-407] -- allow disabling wrapping for unchecked exceptions
+            if (t instanceof RuntimeException) {
+                throw (RuntimeException) t;
+            }
+        }
+        // [JACKSON-55] Need to add reference information
+        throw JsonMappingException.wrapWithPath(t, bean, index);
+    }
+
+    /**
+     * @deprecated Use version that takes <code>SerializerProvider</code> instead.
+     */
+    @Deprecated
+    public void wrapAndThrow(Throwable t, Object bean, String fieldName) throws IOException {
+        wrapAndThrow(null, t, bean, fieldName);
+    }
+
+    /**
+     * @deprecated Use version that takes <code>SerializerProvider</code> instead.
+     */
+    @Deprecated
+    public void wrapAndThrow(Throwable t, Object bean, int index) throws IOException {
+        wrapAndThrow(null, t, bean, index);
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ser/std/StaticListSerializerBase.java

@@ -0,0 +1,46 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.lang.reflect.Type;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+
+/**
+ * Intermediate base class for Lists, Collections and Arrays
+ * that contain static (non-dynamic) value types.
+ * 
+ * @since 1.7
+ */
+public abstract class StaticListSerializerBase<T extends Collection<?>>
+    extends SerializerBase<T>
+{
+    /**
+     * Property that contains String List to serialize, if known.
+     */
+    protected final BeanProperty _property;
+
+    protected StaticListSerializerBase(Class<?> cls, BeanProperty property)
+    {
+        super(cls, false);
+        _property = property;
+    }
+    
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+    {
+        ObjectNode o = createSchemaNode("array", true);
+        o.put("items", contentSchema());
+        return o;
+    }
+
+    /*
+    /**********************************************************
+    /* Abstract methods for sub-classes to implement
+    /**********************************************************
+     */
+
+    protected abstract JsonNode contentSchema();    
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/ser/std/StdArraySerializers.java

@@ -0,0 +1,476 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+
+/**
+ * Dummy container class to group standard homogenous array serializer implementations
+ * (primitive arrays and String array).
+ */
+public class StdArraySerializers
+{
+    protected StdArraySerializers() { }
+
+    /*
+    /**********************************************************
+    /* Base classes
+    /**********************************************************
+     */
+    
+    /**
+     * Base class for serializers that will output contents as JSON
+     * arrays.
+     */
+    public abstract static class ArraySerializerBase<T>
+        extends ContainerSerializerBase<T>
+    {
+         /**
+         * Type serializer used for values, if any.
+         */
+        protected final TypeSerializer _valueTypeSerializer;
+
+        /**
+         * Array-valued property being serialized with this instance
+         * 
+         * @since 1.7
+         */
+        protected final BeanProperty _property;
+        
+        protected ArraySerializerBase(Class<T> cls, TypeSerializer vts, BeanProperty property)
+        {
+            super(cls);
+            _valueTypeSerializer = vts;
+            _property = property;
+        }
+        
+        @Override
+        public final void serialize(T value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeStartArray();
+            serializeContents(value, jgen, provider);
+            jgen.writeEndArray();
+        }
+        
+        @Override
+        public final void serializeWithType(T value, JsonGenerator jgen, SerializerProvider provider,
+                TypeSerializer typeSer)
+            throws IOException, JsonGenerationException
+        {
+            typeSer.writeTypePrefixForArray(value, jgen);
+            serializeContents(value, jgen, provider);
+            typeSer.writeTypeSuffixForArray(value, jgen);
+        }
+
+        protected abstract void serializeContents(T value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException;
+    }
+
+    /*
+     ****************************************************************
+    /* Concrete serializers, arrays
+     ****************************************************************
+     */
+
+    /**
+     * Standard serializer used for <code>String[]</code> values.
+     */
+    @JacksonStdImpl
+    public final static class StringArraySerializer
+        extends ArraySerializerBase<String[]>
+        implements ResolvableSerializer
+    {
+        /**
+         * Value serializer to use, if it's not the standard one
+         * (if it is we can optimize serialization a lot)
+         * 
+         * @since 1.7
+         */
+        protected JsonSerializer<Object> _elementSerializer;
+
+        public StringArraySerializer(BeanProperty prop) {
+            super(String[].class, null, prop);
+        }
+
+        /**
+         * Strings never add type info; hence, even if type serializer is suggested,
+         * we'll ignore it...
+         */
+        @Override
+        public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts) {
+            return this;
+        }
+        
+        @Override
+        public void serializeContents(String[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            final int len = value.length;
+            if (len == 0) {
+                return;
+            }
+            if (_elementSerializer != null) {
+                serializeContentsSlow(value, jgen, provider, _elementSerializer);
+                return;
+            }
+            /* 08-Dec-2008, tatus: If we want this to be fully overridable
+             *  (for example, to support String cleanup during writing
+             *  or something), we should find serializer  by provider.
+             *  But for now, that seems like an overkill: and caller can
+             *  add custom serializer if that is needed as well.
+             * (ditto for null values)
+             */
+            //JsonSerializer<String> ser = (JsonSerializer<String>)provider.findValueSerializer(String.class);
+            for (int i = 0; i < len; ++i) {
+                String str = value[i];
+                if (str == null) {
+                    jgen.writeNull();
+                } else {
+                    //ser.serialize(value[i], jgen, provider);
+                    jgen.writeString(value[i]);
+                }
+            }
+        }
+
+        private void serializeContentsSlow(String[] value, JsonGenerator jgen, SerializerProvider provider,
+                JsonSerializer<Object> ser)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                String str = value[i];
+                if (str == null) {
+                    provider.defaultSerializeNull(jgen);
+                } else {
+                    ser.serialize(value[i], jgen, provider);
+                }
+            }
+        }
+
+        /**
+         * Need to get callback to resolve value serializer, which may
+         * be overridden by custom serializer
+         */
+        @Override
+        public void resolve(SerializerProvider provider)
+            throws JsonMappingException
+        {
+            JsonSerializer<Object> ser = provider.findValueSerializer(String.class, _property);
+            // Retain if not the standard implementation
+            if (ser != null && ser.getClass().getAnnotation(JacksonStdImpl.class) == null) {
+                _elementSerializer = ser;
+            }
+        }        
+        
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            o.put("items", createSchemaNode("string"));
+            return o;
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class BooleanArraySerializer
+        extends ArraySerializerBase<boolean[]>
+    {
+        public BooleanArraySerializer() { super(boolean[].class, null, null); }
+
+        /**
+         * Booleans never add type info; hence, even if type serializer is suggested,
+         * we'll ignore it...
+         */
+        @Override
+        public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts)
+        {
+            return this;
+        }
+        
+        @Override
+        public void serializeContents(boolean[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                jgen.writeBoolean(value[i]);
+            }
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            o.put("items", createSchemaNode("boolean"));
+            return o;
+        }
+    }
+
+    /**
+     * Unlike other integral number array serializers, we do not just print out byte values
+     * as numbers. Instead, we assume that it would make more sense to output content
+     * as base64 encoded bytes (using default base64 encoding).
+     *<p>
+     * NOTE: since it is NOT serialized as an array, can not use AsArraySerializer as base
+     */
+    @JacksonStdImpl
+    public final static class ByteArraySerializer
+        extends SerializerBase<byte[]>
+    {
+        public ByteArraySerializer() {
+            super(byte[].class);
+        }
+        
+        @Override
+        public void serialize(byte[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeBinary(value);
+        }
+
+        @Override
+        public void serializeWithType(byte[] value, JsonGenerator jgen, SerializerProvider provider,
+                TypeSerializer typeSer)
+            throws IOException, JsonGenerationException
+        {
+            typeSer.writeTypePrefixForScalar(value, jgen);
+            jgen.writeBinary(value);
+            typeSer.writeTypeSuffixForScalar(value, jgen);
+        }
+        
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            ObjectNode itemSchema = createSchemaNode("string"); //binary values written as strings?
+            o.put("items", itemSchema);
+            return o;
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class ShortArraySerializer
+        extends ArraySerializerBase<short[]>
+    {
+        public ShortArraySerializer() { this(null); }
+        public ShortArraySerializer(TypeSerializer vts) { super(short[].class, vts, null); }
+
+        @Override
+        public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts) {
+            return new ShortArraySerializer(vts);
+        }
+        
+        @SuppressWarnings("cast")
+        @Override
+        public void serializeContents(short[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                jgen.writeNumber((int)value[i]);
+            }
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            //no "short" type defined by json
+            ObjectNode o = createSchemaNode("array", true);
+            o.put("items", createSchemaNode("integer"));
+            return o;
+        }
+    }
+
+    /**
+     * Character arrays are different from other integral number arrays in that
+     * they are most likely to be textual data, and should be written as
+     * Strings, not arrays of entries.
+     *<p>
+     * NOTE: since it is NOT serialized as an array, can not use AsArraySerializer as base
+     */
+    @JacksonStdImpl
+    public final static class CharArraySerializer
+        extends SerializerBase<char[]>
+    {
+        public CharArraySerializer() { super(char[].class); }
+        
+        @Override
+        public void serialize(char[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            // [JACKSON-289] allows serializing as 'sparse' char array too:
+            if (provider.isEnabled(SerializationConfig.Feature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) {
+                jgen.writeStartArray();
+                _writeArrayContents(jgen, value);
+                jgen.writeEndArray();
+            } else {
+                jgen.writeString(value, 0, value.length);
+            }
+        }
+
+        @Override
+        public void serializeWithType(char[] value, JsonGenerator jgen, SerializerProvider provider,
+                TypeSerializer typeSer)
+            throws IOException, JsonGenerationException
+        {
+            // [JACKSON-289] allows serializing as 'sparse' char array too:
+            if (provider.isEnabled(SerializationConfig.Feature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) {
+                typeSer.writeTypePrefixForArray(value, jgen);
+                _writeArrayContents(jgen, value);
+                typeSer.writeTypeSuffixForArray(value, jgen);
+            } else { // default is to write as simple String
+                typeSer.writeTypePrefixForScalar(value, jgen);
+                jgen.writeString(value, 0, value.length);
+                typeSer.writeTypeSuffixForScalar(value, jgen);
+            }
+        }
+
+        private final void _writeArrayContents(JsonGenerator jgen, char[] value)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                jgen.writeString(value, i, 1);
+            }
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            ObjectNode itemSchema = createSchemaNode("string");
+            itemSchema.put("type", "string");
+            o.put("items", itemSchema);
+            return o;
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class IntArraySerializer
+        extends ArraySerializerBase<int[]>
+    {
+        public IntArraySerializer() { super(int[].class, null, null); }
+
+        /**
+         * Ints never add type info; hence, even if type serializer is suggested,
+         * we'll ignore it...
+         */
+        @Override
+        public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts)
+        {
+            return this;
+        }        
+        
+        @Override
+        public void serializeContents(int[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                jgen.writeNumber(value[i]);
+            }
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            o.put("items", createSchemaNode("integer"));
+            return o;
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class LongArraySerializer
+        extends ArraySerializerBase<long[]>
+    {
+        public LongArraySerializer() { this(null); }
+        public LongArraySerializer(TypeSerializer vts) { super(long[].class, vts, null); }
+
+        @Override
+        public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts) {
+            return new LongArraySerializer(vts);
+        }
+        
+        @Override
+        public void serializeContents(long[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                jgen.writeNumber(value[i]);
+            }
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            o.put("items", createSchemaNode("number", true));
+            return o;
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class FloatArraySerializer
+        extends ArraySerializerBase<float[]>
+    {
+        public FloatArraySerializer() { this(null); }
+        public FloatArraySerializer(TypeSerializer vts) { super(float[].class, vts, null); }
+
+        @Override
+        public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts) {
+            return new FloatArraySerializer(vts);
+        }
+        
+        @Override
+        public void serializeContents(float[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                jgen.writeNumber(value[i]);
+            }
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            o.put("items", createSchemaNode("number"));
+            return o;
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class DoubleArraySerializer
+        extends ArraySerializerBase<double[]>
+    {
+        public DoubleArraySerializer() { super(double[].class, null, null); }
+
+        /**
+         * Doubles never add type info; hence, even if type serializer is suggested,
+         * we'll ignore it...
+         */
+        @Override
+        public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts)
+        {
+            return this;
+        }
+        
+        @Override
+        public void serializeContents(double[] value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            for (int i = 0, len = value.length; i < len; ++i) {
+                jgen.writeNumber(value[i]);
+            }
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            ObjectNode o = createSchemaNode("array", true);
+            o.put("items", createSchemaNode("number"));
+            return o;
+        }
+    }
+}