calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,90 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,476 +0,0 @@
-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;
-        }
-    }
-}