package com.fasterxml.jackson.databind.deser.std; import java.io.IOException; import java.lang.reflect.Array; import java.util.Arrays; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.Nulls; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.annotation.JacksonStdImpl; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.deser.NullValueProvider; import com.fasterxml.jackson.databind.deser.impl.NullsConstantProvider; import com.fasterxml.jackson.databind.deser.impl.NullsFailProvider; import com.fasterxml.jackson.databind.exc.InvalidNullException; import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import com.fasterxml.jackson.databind.util.AccessPattern; import com.fasterxml.jackson.databind.util.ArrayBuilders; /** * Container for deserializers used for instantiating "primitive arrays", * arrays that contain non-object java primitive types. */ @SuppressWarnings("serial") public abstract class PrimitiveArrayDeserializers<T> extends StdDeserializer<T> implements ContextualDeserializer // since 2.7 { /** * Specific override for this instance (from proper, or global per-type overrides) * to indicate whether single value may be taken to mean an unwrapped one-element array * or not. If null, left to global defaults. * * @since 2.7 */ protected final Boolean _unwrapSingle; // since 2.9 private transient Object _emptyValue; /** * Flag that indicates need for special handling; either failing * (throw exception) or skipping */ protected final NullValueProvider _nuller; /* /******************************************************** /* Life-cycle /******************************************************** */ protected PrimitiveArrayDeserializers(Class<T> cls) { super(cls); _unwrapSingle = null; _nuller = null; } /** * @since 2.7 */ protected PrimitiveArrayDeserializers(PrimitiveArrayDeserializers<?> base, NullValueProvider nuller, Boolean unwrapSingle) { super(base._valueClass); _unwrapSingle = unwrapSingle; _nuller = nuller; } public static JsonDeserializer<?> forType(Class<?> rawType) { // Start with more common types... if (rawType == Integer.TYPE) { return IntDeser.instance; } if (rawType == Long.TYPE) { return LongDeser.instance; } if (rawType == Byte.TYPE) { return new ByteDeser(); } if (rawType == Short.TYPE) { return new ShortDeser(); } if (rawType == Float.TYPE) { return new FloatDeser(); } if (rawType == Double.TYPE) { return new DoubleDeser(); } if (rawType == Boolean.TYPE) { return new BooleanDeser(); } if (rawType == Character.TYPE) { return new CharDeser(); } throw new IllegalStateException(); } @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { Boolean unwrapSingle = findFormatFeature(ctxt, property, _valueClass, JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY); NullValueProvider nuller = null; Nulls nullStyle = findContentNullStyle(ctxt, property); if (nullStyle == Nulls.SKIP) { nuller = NullsConstantProvider.skipper(); } else if (nullStyle == Nulls.FAIL) { if (property == null) { nuller = NullsFailProvider.constructForRootValue(ctxt.constructType(_valueClass)); } else { nuller = NullsFailProvider.constructForProperty(property); } } if ((unwrapSingle == _unwrapSingle) && (nuller == _nuller)) { return this; } return withResolved(nuller, unwrapSingle); } /* /******************************************************** /* Abstract methods for sub-classes to implement /******************************************************** */ /** * @since 2.9 */ protected abstract T _concat(T oldValue, T newValue); protected abstract T handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException; /** * @since 2.9 */ protected abstract PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle); // since 2.9 protected abstract T _constructEmpty(); /* /******************************************************** /* Default implementations /******************************************************** */ @Override // since 2.9 public Boolean supportsUpdate(DeserializationConfig config) { return Boolean.TRUE; } @Override public AccessPattern getEmptyAccessPattern() { // Empty values shareable freely return AccessPattern.CONSTANT; } @Override // since 2.9 public Object getEmptyValue(DeserializationContext ctxt) throws JsonMappingException { Object empty = _emptyValue; if (empty == null) { _emptyValue = empty = _constructEmpty(); } return empty; } @Override public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException { // Should there be separate handling for base64 stuff? // for now this should be enough: return typeDeserializer.deserializeTypedFromArray(p, ctxt); } @Override public T deserialize(JsonParser p, DeserializationContext ctxt, T existing) throws IOException { T newValue = deserialize(p, ctxt); if (existing == null) { return newValue; } int len = Array.getLength(existing); if (len == 0) { return newValue; } return _concat(existing, newValue); } /* /******************************************************** /* Helper methods for sub-classes /******************************************************** */ /* * Convenience method that constructs a concatenation of two arrays, * with the type they have. * * @since 2.9 @SuppressWarnings("unchecked") public static <T> T concatArrays(T array1, T array2) { int len1 = Array.getLength(array1); if (len1 == 0) { return array2; } int len2 = Array.getLength(array2); if (len2 == 0) { return array1; } Object result = Arrays.copyOf((Object[]) array1, len1 + len2); System.arraycopy(array2, 0, result, len1, len2); return (T) result; } */ @SuppressWarnings("unchecked") protected T handleNonArray(JsonParser p, DeserializationContext ctxt) throws IOException { // Empty String can become null... if (p.hasToken(JsonToken.VALUE_STRING) && ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) { if (p.getText().length() == 0) { return null; } } boolean canWrap = (_unwrapSingle == Boolean.TRUE) || ((_unwrapSingle == null) && ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)); if (canWrap) { return handleSingleElementUnwrapped(p, ctxt); } return (T) ctxt.handleUnexpectedToken(_valueClass, p); } protected void _failOnNull(DeserializationContext ctxt) throws IOException { throw InvalidNullException.from(ctxt, null, ctxt.constructType(_valueClass)); } /* /******************************************************** /* Actual deserializers: efficient String[], char[] deserializers /******************************************************** */ @JacksonStdImpl final static class CharDeser extends PrimitiveArrayDeserializers<char[]> { private static final long serialVersionUID = 1L; public CharDeser() { super(char[].class); } protected CharDeser(CharDeser base, NullValueProvider nuller, Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { // 11-Dec-2015, tatu: Not sure how re-wrapping would work; omit return this; } @Override protected char[] _constructEmpty() { return new char[0]; } @Override public char[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { /* 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 = p.getCurrentToken(); if (t == JsonToken.VALUE_STRING) { // note: can NOT return shared internal buffer, must copy: char[] buffer = p.getTextCharacters(); int offset = p.getTextOffset(); int len = p.getTextLength(); char[] result = new char[len]; System.arraycopy(buffer, offset, result, 0, len); return result; } if (p.isExpectedStartArrayToken()) { // Let's actually build as a String, then get chars StringBuilder sb = new StringBuilder(64); while ((t = p.nextToken()) != JsonToken.END_ARRAY) { String str; if (t == JsonToken.VALUE_STRING) { str = p.getText(); } else if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } _verifyNullForPrimitive(ctxt); str = "\0"; } else { CharSequence cs = (CharSequence) ctxt.handleUnexpectedToken(Character.TYPE, p); str = cs.toString(); } if (str.length() != 1) { ctxt.reportInputMismatch(this, "Can not convert a JSON String of length %d into a char element of char array", str.length()); } sb.append(str.charAt(0)); } return sb.toString().toCharArray(); } // or, maybe an embedded object? if (t == JsonToken.VALUE_EMBEDDED_OBJECT) { Object ob = p.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 } return (char[]) ctxt.handleUnexpectedToken(_valueClass, p); } @Override protected char[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { // not sure how this should work... return (char[]) ctxt.handleUnexpectedToken(_valueClass, p); } @Override protected char[] _concat(char[] oldValue, char[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; char[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } /* /********************************************************** /* Actual deserializers: primivate array desers /********************************************************** */ @JacksonStdImpl final static class BooleanDeser extends PrimitiveArrayDeserializers<boolean[]> { private static final long serialVersionUID = 1L; public BooleanDeser() { super(boolean[].class); } protected BooleanDeser(BooleanDeser base, NullValueProvider nuller, Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { return new BooleanDeser(this, nuller, unwrapSingle); } @Override protected boolean[] _constructEmpty() { return new boolean[0]; } @Override public boolean[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt); } ArrayBuilders.BooleanBuilder builder = ctxt.getArrayBuilders().getBooleanBuilder(); boolean[] chunk = builder.resetAndStart(); int ix = 0; try { JsonToken t; while ((t = p.nextToken()) != JsonToken.END_ARRAY) { boolean value; if (t == JsonToken.VALUE_TRUE) { value = true; } else if (t == JsonToken.VALUE_FALSE) { value = false; } else if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } _verifyNullForPrimitive(ctxt); value = false; } else { value = _parseBooleanPrimitive(p, ctxt); } if (ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, builder.bufferedSize() + ix); } return builder.completeAndClearBuffer(chunk, ix); } @Override protected boolean[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { return new boolean[] { _parseBooleanPrimitive(p, ctxt) }; } @Override protected boolean[] _concat(boolean[] oldValue, boolean[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; boolean[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } /** * When dealing with byte arrays we have one more alternative (compared * to int/long/shorts): base64 encoded data. */ @JacksonStdImpl final static class ByteDeser extends PrimitiveArrayDeserializers<byte[]> { private static final long serialVersionUID = 1L; public ByteDeser() { super(byte[].class); } protected ByteDeser(ByteDeser base, NullValueProvider nuller,Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { return new ByteDeser(this, nuller, unwrapSingle); } @Override protected byte[] _constructEmpty() { return new byte[0]; } @Override public byte[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { JsonToken t = p.getCurrentToken(); // Most likely case: base64 encoded String? if (t == JsonToken.VALUE_STRING) { try { return p.getBinaryValue(ctxt.getBase64Variant()); } catch (JsonParseException e) { // 25-Nov-2016, tatu: related to [databind#1425], try to convert // to a more usable one, as it's not really a JSON-level parse // exception, but rather binding from JSON String into base64 decoded // binary data String msg = e.getOriginalMessage(); if (msg.contains("base64")) { return (byte[]) ctxt.handleWeirdStringValue(byte[].class, p.getText(), msg); } } } // 31-Dec-2009, tatu: Also may be hidden as embedded Object if (t == JsonToken.VALUE_EMBEDDED_OBJECT) { Object ob = p.getEmbeddedObject(); if (ob == null) return null; if (ob instanceof byte[]) { return (byte[]) ob; } } if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt); } ArrayBuilders.ByteBuilder builder = ctxt.getArrayBuilders().getByteBuilder(); byte[] chunk = builder.resetAndStart(); int ix = 0; try { while ((t = p.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 = p.getByteValue(); } else { // should probably accept nulls as 0 if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } _verifyNullForPrimitive(ctxt); value = (byte) 0; } else { value = _parseBytePrimitive(p, ctxt); } } if (ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, builder.bufferedSize() + ix); } return builder.completeAndClearBuffer(chunk, ix); } @Override protected byte[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { byte value; JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_NUMBER_INT || t == JsonToken.VALUE_NUMBER_FLOAT) { // should we catch overflow exceptions? value = p.getByteValue(); } else { // should probably accept nulls as 'false' if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); return (byte[]) getEmptyValue(ctxt); } _verifyNullForPrimitive(ctxt); return null; } Number n = (Number) ctxt.handleUnexpectedToken(_valueClass.getComponentType(), p); value = n.byteValue(); } return new byte[] { value }; } @Override protected byte[] _concat(byte[] oldValue, byte[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; byte[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } @JacksonStdImpl final static class ShortDeser extends PrimitiveArrayDeserializers<short[]> { private static final long serialVersionUID = 1L; public ShortDeser() { super(short[].class); } protected ShortDeser(ShortDeser base, NullValueProvider nuller, Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { return new ShortDeser(this, nuller, unwrapSingle); } @Override protected short[] _constructEmpty() { return new short[0]; } @Override public short[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt); } ArrayBuilders.ShortBuilder builder = ctxt.getArrayBuilders().getShortBuilder(); short[] chunk = builder.resetAndStart(); int ix = 0; try { JsonToken t; while ((t = p.nextToken()) != JsonToken.END_ARRAY) { short value; if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } _verifyNullForPrimitive(ctxt); value = (short) 0; } else { value = _parseShortPrimitive(p, ctxt); } if (ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, builder.bufferedSize() + ix); } return builder.completeAndClearBuffer(chunk, ix); } @Override protected short[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { return new short[] { _parseShortPrimitive(p, ctxt) }; } @Override protected short[] _concat(short[] oldValue, short[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; short[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } @JacksonStdImpl final static class IntDeser extends PrimitiveArrayDeserializers<int[]> { private static final long serialVersionUID = 1L; public final static IntDeser instance = new IntDeser(); public IntDeser() { super(int[].class); } protected IntDeser(IntDeser base, NullValueProvider nuller, Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { return new IntDeser(this, nuller, unwrapSingle); } @Override protected int[] _constructEmpty() { return new int[0]; } @Override public int[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt); } ArrayBuilders.IntBuilder builder = ctxt.getArrayBuilders().getIntBuilder(); int[] chunk = builder.resetAndStart(); int ix = 0; try { JsonToken t; while ((t = p.nextToken()) != JsonToken.END_ARRAY) { int value; if (t == JsonToken.VALUE_NUMBER_INT) { value = p.getIntValue(); } else if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } _verifyNullForPrimitive(ctxt); value = 0; } else { value = _parseIntPrimitive(p, ctxt); } if (ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, builder.bufferedSize() + ix); } return builder.completeAndClearBuffer(chunk, ix); } @Override protected int[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { return new int[] { _parseIntPrimitive(p, ctxt) }; } @Override protected int[] _concat(int[] oldValue, int[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; int[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } @JacksonStdImpl final static class LongDeser extends PrimitiveArrayDeserializers<long[]> { private static final long serialVersionUID = 1L; public final static LongDeser instance = new LongDeser(); public LongDeser() { super(long[].class); } protected LongDeser(LongDeser base, NullValueProvider nuller, Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { return new LongDeser(this, nuller, unwrapSingle); } @Override protected long[] _constructEmpty() { return new long[0]; } @Override public long[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt); } ArrayBuilders.LongBuilder builder = ctxt.getArrayBuilders().getLongBuilder(); long[] chunk = builder.resetAndStart(); int ix = 0; try { JsonToken t; while ((t = p.nextToken()) != JsonToken.END_ARRAY) { long value; if (t == JsonToken.VALUE_NUMBER_INT) { value = p.getLongValue(); } else if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } _verifyNullForPrimitive(ctxt); value = 0L; } else { value = _parseLongPrimitive(p, ctxt); } if (ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, builder.bufferedSize() + ix); } return builder.completeAndClearBuffer(chunk, ix); } @Override protected long[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { return new long[] { _parseLongPrimitive(p, ctxt) }; } @Override protected long[] _concat(long[] oldValue, long[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; long[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } @JacksonStdImpl final static class FloatDeser extends PrimitiveArrayDeserializers<float[]> { private static final long serialVersionUID = 1L; public FloatDeser() { super(float[].class); } protected FloatDeser(FloatDeser base, NullValueProvider nuller, Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { return new FloatDeser(this, nuller, unwrapSingle); } @Override protected float[] _constructEmpty() { return new float[0]; } @Override public float[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt); } ArrayBuilders.FloatBuilder builder = ctxt.getArrayBuilders().getFloatBuilder(); float[] chunk = builder.resetAndStart(); int ix = 0; try { JsonToken t; while ((t = p.nextToken()) != JsonToken.END_ARRAY) { // whether we should allow truncating conversions? if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } } float value = _parseFloatPrimitive(p, ctxt); if (ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, builder.bufferedSize() + ix); } return builder.completeAndClearBuffer(chunk, ix); } @Override protected float[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { return new float[] { _parseFloatPrimitive(p, ctxt) }; } @Override protected float[] _concat(float[] oldValue, float[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; float[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } @JacksonStdImpl final static class DoubleDeser extends PrimitiveArrayDeserializers<double[]> { private static final long serialVersionUID = 1L; public DoubleDeser() { super(double[].class); } protected DoubleDeser(DoubleDeser base, NullValueProvider nuller, Boolean unwrapSingle) { super(base, nuller, unwrapSingle); } @Override protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller, Boolean unwrapSingle) { return new DoubleDeser(this, nuller, unwrapSingle); } @Override protected double[] _constructEmpty() { return new double[0]; } @Override public double[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt); } ArrayBuilders.DoubleBuilder builder = ctxt.getArrayBuilders().getDoubleBuilder(); double[] chunk = builder.resetAndStart(); int ix = 0; try { JsonToken t; while ((t = p.nextToken()) != JsonToken.END_ARRAY) { if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { _nuller.getNullValue(ctxt); continue; } } double value = _parseDoublePrimitive(p, ctxt); if (ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, chunk, builder.bufferedSize() + ix); } return builder.completeAndClearBuffer(chunk, ix); } @Override protected double[] handleSingleElementUnwrapped(JsonParser p, DeserializationContext ctxt) throws IOException { return new double[] { _parseDoublePrimitive(p, ctxt) }; } @Override protected double[] _concat(double[] oldValue, double[] newValue) { int len1 = oldValue.length; int len2 = newValue.length; double[] result = Arrays.copyOf(oldValue, len1+len2); System.arraycopy(newValue, 0, result, len1, len2); return result; } } }