com.fasterxml.jackson.databind.deser.std.PrimitiveArrayDeserializers Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ehcache Show documentation
Show all versions of ehcache Show documentation
Ehcache is an open source, standards-based cache used to boost performance,
offload the database and simplify scalability. Ehcache is robust, proven and full-featured and
this has made it the most widely-used Java-based cache.
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 extends StdDeserializer
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 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 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
{
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,
"Cannot 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
{
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
{
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
{
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
{
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
{
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
{
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
{
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;
}
}
}