calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,201 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.io.IOException;
-import java.lang.reflect.Array;
-
-import sh.calaba.org.codehaus.jackson.JsonParser;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.JsonToken;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
-import sh.calaba.org.codehaus.jackson.map.type.ArrayType;
-import sh.calaba.org.codehaus.jackson.map.util.ObjectBuffer;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Basic serializer that can serialize non-primitive arrays.
- */
-@JacksonStdImpl
-public class ObjectArrayDeserializer
-    extends ContainerDeserializerBase<Object[]>
-{
-    // // Configuration
-
-    protected final JavaType _arrayType;
-    
-    /**
-     * Flag that indicates whether the component type is Object or not.
-     * Used for minor optimization when constructing result.
-     */
-    protected final boolean _untyped;
-
-    /**
-     * Type of contained elements: needed for constructing actual
-     * result array
-     */
-    protected final Class<?> _elementClass;
-
-    /**
-     * Element deserializer
-     */
-    protected final JsonDeserializer<Object> _elementDeserializer;
-
-    /**
-     * If element instances have polymorphic type information, this
-     * is the type deserializer that can handle it
-     */
-    protected final TypeDeserializer _elementTypeDeserializer;
-
-    public ObjectArrayDeserializer(ArrayType arrayType, JsonDeserializer<Object> elemDeser,
-            TypeDeserializer elemTypeDeser)
-    {
-        super(Object[].class);
-        _arrayType = arrayType;
-        _elementClass = arrayType.getContentType().getRawClass();
-        _untyped = (_elementClass == Object.class);
-        _elementDeserializer = elemDeser;
-        _elementTypeDeserializer = elemTypeDeser;
-    }
-
-    /*
-    /**********************************************************
-    /* ContainerDeserializerBase API
-    /**********************************************************
-     */
-
-    @Override
-    public JavaType getContentType() {
-        return _arrayType.getContentType();
-    }
-
-    @Override
-    public JsonDeserializer<Object> getContentDeserializer() {
-        return _elementDeserializer;
-    }
-    
-    /*
-    /**********************************************************
-    /* JsonDeserializer API
-    /**********************************************************
-     */
-    
-    @Override
-    public Object[] deserialize(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        // Ok: must point to START_ARRAY (or equivalent)
-        if (!jp.isExpectedStartArrayToken()) {
-            return handleNonArray(jp, ctxt);
-        }
-
-        final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
-        Object[] chunk = buffer.resetAndStart();
-        int ix = 0;
-        JsonToken t;
-        final TypeDeserializer typeDeser = _elementTypeDeserializer;
-
-        while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
-            // Note: must handle null explicitly here; value deserializers won't
-            Object value;
-            
-            if (t == JsonToken.VALUE_NULL) {
-                value = null;
-            } else if (typeDeser == null) {
-                value = _elementDeserializer.deserialize(jp, ctxt);
-            } else {
-                value = _elementDeserializer.deserializeWithType(jp, ctxt, typeDeser);
-            }
-            if (ix >= chunk.length) {
-                chunk = buffer.appendCompletedChunk(chunk);
-                ix = 0;
-            }
-            chunk[ix++] = value;
-        }
-
-        Object[] result;
-
-        if (_untyped) {
-            result = buffer.completeAndClearBuffer(chunk, ix);
-        } else {
-            result = buffer.completeAndClearBuffer(chunk, ix, _elementClass);
-        }
-        ctxt.returnObjectBuffer(buffer);
-        return result;
-    }
-
-    @Override
-    public Object[] deserializeWithType(JsonParser jp, DeserializationContext ctxt,
-            TypeDeserializer typeDeserializer)
-        throws IOException, JsonProcessingException
-    {
-        /* Should there be separate handling for base64 stuff?
-         * for now this should be enough:
-         */
-        return (Object[]) typeDeserializer.deserializeTypedFromArray(jp, ctxt);
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-    
-    protected Byte[] deserializeFromBase64(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        // First same as what PrimitiveArrayDeserializers.ByteDeser does:
-        byte[] b = jp.getBinaryValue(ctxt.getBase64Variant());
-        // But then need to convert to wrappers
-        Byte[] result = new Byte[b.length];
-        for (int i = 0, len = b.length; i < len; ++i) {
-            result[i] = Byte.valueOf(b[i]);
-        }
-        return result;
-    }
-
-    private final Object[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException
-    {
-        // [JACKSON-620] Empty String can become null...
-        if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-            String str = jp.getText();
-            if (str.length() == 0) {
-                return null;
-            }
-        }
-        
-        // Can we do implicit coercion to a single-element array still?
-        if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-            /* 04-Oct-2009, tatu: One exception; byte arrays are generally
-             *   serialized as base64, so that should be handled
-             */
-            if (jp.getCurrentToken() == JsonToken.VALUE_STRING
-                && _elementClass == Byte.class) {
-                return deserializeFromBase64(jp, ctxt);
-            }
-            throw ctxt.mappingException(_arrayType.getRawClass());
-        }
-        JsonToken t = jp.getCurrentToken();
-        Object value;
-        
-        if (t == JsonToken.VALUE_NULL) {
-            value = null;
-        } else if (_elementTypeDeserializer == null) {
-            value = _elementDeserializer.deserialize(jp, ctxt);
-        } else {
-            value = _elementDeserializer.deserializeWithType(jp, ctxt, _elementTypeDeserializer);
-        }
-        // Ok: bit tricky, since we may want T[], not just Object[]
-        Object[] result;
-
-        if (_untyped) {
-            result = new Object[1];
-        } else {
-            result = (Object[]) Array.newInstance(_elementClass, 1);
-        }
-        result[0] = value;
-        return result;
-    }
-}
-

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

@@ -1,583 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.deser.std;
-
-import java.io.IOException;
-import java.util.*;
-
-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.map.type.*;
-import sh.calaba.org.codehaus.jackson.map.util.ArrayBuilders;
-import sh.calaba.org.codehaus.jackson.map.util.ObjectBuffer;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Container for deserializers used for instantiating "primitive arrays",
- * arrays that contain non-object java primitive types.
- * 
- * @since 1.9 (renamed from 'sh.calaba.org.codehaus.jackson.map.deser.ArrayDeserilizers)
- */
-public class PrimitiveArrayDeserializers
-{
-    HashMap<JavaType,JsonDeserializer<Object>> _allDeserializers;
-
-    final static PrimitiveArrayDeserializers instance = new PrimitiveArrayDeserializers();
-
-    protected PrimitiveArrayDeserializers()
-    {
-        _allDeserializers = new HashMap<JavaType,JsonDeserializer<Object>>();
-        // note: we'll use component type as key, not array type
-        add(boolean.class, new BooleanDeser());
-
-        /* ByteDeser is bit special, as it has 2 separate modes of operation;
-         * one for String input (-> base64 input), the other for
-         * numeric input
-         */
-        add(byte.class, new ByteDeser());
-        add(short.class, new ShortDeser());
-        add(int.class, new IntDeser());
-        add(long.class, new LongDeser());
-
-        add(float.class, new FloatDeser());
-        add(double.class, new DoubleDeser());
-
-        add(String.class, new StringDeser());
-        /* also: char[] is most likely only used with Strings; doesn't
-         * seem to make sense to transfer as numbers
-         */
-        add(char.class, new CharDeser());
-    }
-
-    public static HashMap<JavaType,JsonDeserializer<Object>> getAll()
-    {
-        return instance._allDeserializers;
-    }
-
-    @SuppressWarnings("unchecked")
-    private void add(Class<?> cls, JsonDeserializer<?> deser)
-    {
-        /* Not super clean to use default TypeFactory in general, but
-         * since primitive array types can't be modified for anything
-         * useful, this should be ok:
-         */
-        _allDeserializers.put(TypeFactory.defaultInstance().constructType(cls),
-                (JsonDeserializer<Object>) deser);
-    }
-
-    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
-            TypeDeserializer typeDeserializer)
-        throws IOException, JsonProcessingException
-    {
-        /* Should there be separate handling for base64 stuff?
-         * for now this should be enough:
-         */
-        return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
-    }
-
-    /*
-    /********************************************************
-    /* Intermediate base class
-    /********************************************************
-     */
-    
-    /**
-     * Intermediate base class for primitive array deserializers
-     */
-    static abstract class Base<T> extends StdDeserializer<T>
-    {
-        protected Base(Class<T> cls) {
-            super(cls);
-        }
-
-        @Override
-        public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
-            TypeDeserializer typeDeserializer)
-            throws IOException, JsonProcessingException
-        {
-            return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
-        }
-    }
-    
-    /*
-    /********************************************************
-    /* Actual deserializers: efficient String[], char[] deserializers
-    /********************************************************
-    */
-
-    @JacksonStdImpl
-    final static class StringDeser
-        extends Base<String[]>
-    {
-        public StringDeser() { super(String[].class); }
-
-        @Override
-        public String[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // Ok: must point to START_ARRAY (or equivalent)
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
-            Object[] chunk = buffer.resetAndStart();
-            int ix = 0;
-            JsonToken t;
-            
-            while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
-                // Ok: no need to convert Strings, but must recognize nulls
-                String value = (t == JsonToken.VALUE_NULL) ? null : jp.getText();
-                if (ix >= chunk.length) {
-                    chunk = buffer.appendCompletedChunk(chunk);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class);
-            ctxt.returnObjectBuffer(buffer);
-            return result;
-        }
-    
-        private final String[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-526]: implicit arrays from single values?
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                // [JACKSON-620] Empty String can become null...
-                if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                        && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                    String str = jp.getText();
-                    if (str.length() == 0) {
-                        return null;
-                    }
-                }
-                throw ctxt.mappingException(_valueClass);
-            }
-            return new String[] { (jp.getCurrentToken() == JsonToken.VALUE_NULL) ? null : jp.getText() };
-        }
-    }
-    
-    @JacksonStdImpl
-    final static class CharDeser
-        extends Base<char[]>
-    {
-        public CharDeser() { super(char[].class); }
-
-        @Override
-        public char[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            /* Won't take arrays, must get a String (could also
-             * convert other tokens to Strings... but let's not bother
-             * yet, doesn't seem to make sense)
-             */
-            JsonToken t = jp.getCurrentToken();
-            if (t == JsonToken.VALUE_STRING) {
-                // note: can NOT return shared internal buffer, must copy:
-                char[] buffer = jp.getTextCharacters();
-                int offset = jp.getTextOffset();
-                int len = jp.getTextLength();
-    
-                char[] result = new char[len];
-                System.arraycopy(buffer, offset, result, 0, len);
-                return result;
-            }
-            if (jp.isExpectedStartArrayToken()) {
-                // Let's actually build as a String, then get chars
-                StringBuilder sb = new StringBuilder(64);
-                while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
-                    if (t != JsonToken.VALUE_STRING) {
-                        throw ctxt.mappingException(Character.TYPE);
-                    }
-                    String str = jp.getText();
-                    if (str.length() != 1) {
-                        throw JsonMappingException.from(jp, "Can not convert a JSON String of length "+str.length()+" into a char element of char array");
-                    }
-                    sb.append(str.charAt(0));
-                }
-                return sb.toString().toCharArray();
-            }
-            // or, maybe an embedded object?
-            if (t == JsonToken.VALUE_EMBEDDED_OBJECT) {
-                Object ob = jp.getEmbeddedObject();
-                if (ob == null) return null;
-                if (ob instanceof char[]) {
-                    return (char[]) ob;
-                }
-                if (ob instanceof String) {
-                    return ((String) ob).toCharArray();
-                }
-                // 04-Feb-2011, tatu: byte[] can be converted; assuming base64 is wanted
-                if (ob instanceof byte[]) {
-                    return Base64Variants.getDefaultVariant().encode((byte[]) ob, false).toCharArray();
-                }
-                // not recognized, just fall through
-            }
-            throw ctxt.mappingException(_valueClass);
-        }
-    }
-
-    /*
-    /********************************************************
-    /* Actual deserializers: primivate array desers
-    /********************************************************
-    */
-
-    @JacksonStdImpl
-    final static class BooleanDeser
-        extends Base<boolean[]>
-    {
-        public BooleanDeser() { super(boolean[].class); }
-
-        @Override
-        public boolean[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            ArrayBuilders.BooleanBuilder builder = ctxt.getArrayBuilders().getBooleanBuilder();
-            boolean[] chunk = builder.resetAndStart();
-            int ix = 0;
-
-            while (jp.nextToken() != JsonToken.END_ARRAY) {
-                // whether we should allow truncating conversions?
-                boolean value = _parseBooleanPrimitive(jp, ctxt);
-                if (ix >= chunk.length) {
-                    chunk = builder.appendCompletedChunk(chunk, ix);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            return builder.completeAndClearBuffer(chunk, ix);
-        }
-
-        private final boolean[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-620] Empty String can become null...
-            if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                    && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                if (jp.getText().length() == 0) {
-                    return null;
-                }
-            }
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                throw ctxt.mappingException(_valueClass);
-            }
-            return new boolean[] { _parseBooleanPrimitive(jp, ctxt) };
-        }
-    }
-
-    /**
-     * When dealing with byte arrays we have one more alternative (compared
-     * to int/long/shorts): base64 encoded data.
-     */
-    @JacksonStdImpl
-    final static class ByteDeser
-        extends Base<byte[]>
-    {
-        public ByteDeser() { super(byte[].class); }
-
-        @Override
-        public byte[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            JsonToken t = jp.getCurrentToken();
-            
-            // Most likely case: base64 encoded String?
-            if (t == JsonToken.VALUE_STRING) {
-                return jp.getBinaryValue(ctxt.getBase64Variant());
-            }
-            // 31-Dec-2009, tatu: Also may be hidden as embedded Object
-            if (t == JsonToken.VALUE_EMBEDDED_OBJECT) {
-                Object ob = jp.getEmbeddedObject();
-                if (ob == null) return null;
-                if (ob instanceof byte[]) {
-                    return (byte[]) ob;
-                }
-            }
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            ArrayBuilders.ByteBuilder builder = ctxt.getArrayBuilders().getByteBuilder();
-            byte[] chunk = builder.resetAndStart();
-            int ix = 0;
-
-            while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
-                // whether we should allow truncating conversions?
-                byte value;
-                if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) {
-                    // should we catch overflow exceptions?
-                    value = jp.getByteValue();
-                } else {
-                    // [JACKSON-79]: should probably accept nulls as 0
-                    if (t != JsonToken.VALUE_NULL) {
-                        throw ctxt.mappingException(_valueClass.getComponentType());
-                    }
-                    value = (byte) 0;
-                }
-                if (ix >= chunk.length) {
-                    chunk = builder.appendCompletedChunk(chunk, ix);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            return builder.completeAndClearBuffer(chunk, ix);
-        }
-
-        private final byte[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-620] Empty String can become null...
-            if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                    && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                if (jp.getText().length() == 0) {
-                    return null;
-                }
-            }
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                throw ctxt.mappingException(_valueClass);
-            }
-            byte value;
-            JsonToken t = jp.getCurrentToken();
-            if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) {
-                // should we catch overflow exceptions?
-                value = jp.getByteValue();
-            } else {
-                // [JACKSON-79]: should probably accept nulls as 'false'
-                if (t != JsonToken.VALUE_NULL) {
-                    throw ctxt.mappingException(_valueClass.getComponentType());
-                }
-                value = (byte) 0;
-            }
-            return new byte[] { value };
-        }
-    }
-
-    @JacksonStdImpl
-    final static class ShortDeser
-        extends Base<short[]>
-    {
-        public ShortDeser() { super(short[].class); }
-
-        @Override
-        public short[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            ArrayBuilders.ShortBuilder builder = ctxt.getArrayBuilders().getShortBuilder();
-            short[] chunk = builder.resetAndStart();
-            int ix = 0;
-
-            while (jp.nextToken() != JsonToken.END_ARRAY) {
-                short value = _parseShortPrimitive(jp, ctxt);
-                if (ix >= chunk.length) {
-                    chunk = builder.appendCompletedChunk(chunk, ix);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            return builder.completeAndClearBuffer(chunk, ix);
-        }
-
-        private final short[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-620] Empty String can become null...
-            if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                    && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                if (jp.getText().length() == 0) {
-                    return null;
-                }
-            }
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                throw ctxt.mappingException(_valueClass);
-            }
-            return new short[] { _parseShortPrimitive(jp, ctxt) };
-        }
-    }
-
-    @JacksonStdImpl
-    final static class IntDeser
-        extends Base<int[]>
-    {
-        public IntDeser() { super(int[].class); }
-
-        @Override
-        public int[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            ArrayBuilders.IntBuilder builder = ctxt.getArrayBuilders().getIntBuilder();
-            int[] chunk = builder.resetAndStart();
-            int ix = 0;
-
-            while (jp.nextToken() != JsonToken.END_ARRAY) {
-                // whether we should allow truncating conversions?
-                int value = _parseIntPrimitive(jp, ctxt);
-                if (ix >= chunk.length) {
-                    chunk = builder.appendCompletedChunk(chunk, ix);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            return builder.completeAndClearBuffer(chunk, ix);
-        }
-
-        private final int[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-620] Empty String can become null...
-            if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                    && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                if (jp.getText().length() == 0) {
-                    return null;
-                }
-            }
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                throw ctxt.mappingException(_valueClass);
-            }
-            return new int[] { _parseIntPrimitive(jp, ctxt) };
-        }
-    }
-
-    @JacksonStdImpl
-    final static class LongDeser
-        extends Base<long[]>
-    {
-        public LongDeser() { super(long[].class); }
-
-        @Override
-        public long[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            ArrayBuilders.LongBuilder builder = ctxt.getArrayBuilders().getLongBuilder();
-            long[] chunk = builder.resetAndStart();
-            int ix = 0;
-
-            while (jp.nextToken() != JsonToken.END_ARRAY) {
-                long value = _parseLongPrimitive(jp, ctxt);
-                if (ix >= chunk.length) {
-                    chunk = builder.appendCompletedChunk(chunk, ix);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            return builder.completeAndClearBuffer(chunk, ix);
-        }
-
-        private final long[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-620] Empty String can become null...
-            if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                    && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                if (jp.getText().length() == 0) {
-                    return null;
-                }
-            }
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                throw ctxt.mappingException(_valueClass);
-            }
-            return new long[] { _parseLongPrimitive(jp, ctxt) };
-        }
-    }
-
-    @JacksonStdImpl
-    final static class FloatDeser
-        extends Base<float[]>
-    {
-        public FloatDeser() { super(float[].class); }
-
-        @Override
-        public float[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            ArrayBuilders.FloatBuilder builder = ctxt.getArrayBuilders().getFloatBuilder();
-            float[] chunk = builder.resetAndStart();
-            int ix = 0;
-
-            while (jp.nextToken() != JsonToken.END_ARRAY) {
-                // whether we should allow truncating conversions?
-                float value = _parseFloatPrimitive(jp, ctxt);
-                if (ix >= chunk.length) {
-                    chunk = builder.appendCompletedChunk(chunk, ix);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            return builder.completeAndClearBuffer(chunk, ix);
-        }
-
-        private final float[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-620] Empty String can become null...
-            if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                    && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                if (jp.getText().length() == 0) {
-                    return null;
-                }
-            }
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                throw ctxt.mappingException(_valueClass);
-            }
-            return new float[] { _parseFloatPrimitive(jp, ctxt) };
-        }
-    }
-
-    @JacksonStdImpl
-    final static class DoubleDeser
-        extends Base<double[]>
-    {
-        public DoubleDeser() { super(double[].class); }
-
-        @Override
-        public double[] deserialize(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            if (!jp.isExpectedStartArrayToken()) {
-                return handleNonArray(jp, ctxt);
-            }
-            ArrayBuilders.DoubleBuilder builder = ctxt.getArrayBuilders().getDoubleBuilder();
-            double[] chunk = builder.resetAndStart();
-            int ix = 0;
-
-            while (jp.nextToken() != JsonToken.END_ARRAY) {
-                double value = _parseDoublePrimitive(jp, ctxt);
-                if (ix >= chunk.length) {
-                    chunk = builder.appendCompletedChunk(chunk, ix);
-                    ix = 0;
-                }
-                chunk[ix++] = value;
-            }
-            return builder.completeAndClearBuffer(chunk, ix);
-        }
-
-        private final double[] handleNonArray(JsonParser jp, DeserializationContext ctxt)
-            throws IOException, JsonProcessingException
-        {
-            // [JACKSON-620] Empty String can become null...
-            if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
-                    && ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
-                if (jp.getText().length() == 0) {
-                    return null;
-                }
-            }
-            if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
-                throw ctxt.mappingException(_valueClass);
-            }
-            return new double[] { _parseDoublePrimitive(jp, ctxt) };
-        }
-    }
-}