/** Unit test to check for regression of [JACKSON-18]. */
public void testSmallNumbers() throws Exception {
ObjectMapper mapper = new ObjectMapper();
ArrayNode root = mapper.createArrayNode();
for (int i = -20; i <= 20; ++i) {
JsonNode n = root.numberNode(i);
root.add(n);
// Hmmh. Not sure why toString() won't be triggered otherwise...
assertEquals(String.valueOf(i), n.toString());
}
// Loop over 2 different serialization methods
for (int type = 0; type < 2; ++type) {
StringWriter sw = new StringWriter();
if (type == 0) {
JsonGenerator gen = new JsonFactory().createGenerator(sw);
root.serialize(gen, null);
gen.close();
} else {
mapper.writeValue(sw, root);
}
String doc = sw.toString();
JsonParser p = new JsonFactory().createParser(new StringReader(doc));
assertEquals(JsonToken.START_ARRAY, p.nextToken());
for (int i = -20; i <= 20; ++i) {
assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken());
assertEquals(i, p.getIntValue());
assertEquals("" + i, p.getText());
}
assertEquals(JsonToken.END_ARRAY, p.nextToken());
p.close();
}
}
@Override
public Collection<String> deserialize(
JsonParser jp, DeserializationContext ctxt, Collection<String> result) throws IOException {
// Ok: must point to START_ARRAY
if (!jp.isExpectedStartArrayToken()) {
return handleNonArray(jp, ctxt, result);
}
if (_valueDeserializer != null) {
return deserializeUsingCustom(jp, ctxt, result, _valueDeserializer);
}
JsonToken t;
while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
String value;
if (t == JsonToken.VALUE_STRING) {
value = jp.getText();
} else if (t == JsonToken.VALUE_NULL) {
value = null;
} else {
value = _parseString(jp, ctxt);
}
result.add(value);
}
return result;
}
/** Offlined version used when we do not use the default deserialization method. */
protected final String[] _deserializeCustom(
JsonParser p, DeserializationContext ctxt, String[] old) throws IOException {
final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
int ix;
Object[] chunk;
if (old == null) {
ix = 0;
chunk = buffer.resetAndStart();
} else {
ix = old.length;
chunk = buffer.resetAndStart(old, ix);
}
final JsonDeserializer<String> deser = _elementDeserializer;
try {
while (true) {
/* 30-Dec-2014, tatu: This may look odd, but let's actually call method
* that suggest we are expecting a String; this helps with some formats,
* notably XML. Note, however, that while we can get String, we can't
* assume that's what we use due to custom deserializer
*/
String value;
if (p.nextTextValue() == null) {
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
// Ok: no need to convert Strings, but must recognize nulls
value =
(t == JsonToken.VALUE_NULL) ? deser.getNullValue(ctxt) : deser.deserialize(p, ctxt);
} else {
value = deser.deserialize(p, ctxt);
}
if (ix >= chunk.length) {
chunk = buffer.appendCompletedChunk(chunk);
ix = 0;
}
chunk[ix++] = value;
}
} catch (Exception e) {
// note: pass String.class, not String[].class, as we need element type for error info
throw JsonMappingException.wrapWithPath(e, String.class, ix);
}
String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class);
ctxt.returnObjectBuffer(buffer);
return result;
}
@Override
public String[] deserialize(JsonParser p, DeserializationContext ctxt, String[] intoValue)
throws IOException {
// Ok: must point to START_ARRAY (or equivalent)
if (!p.isExpectedStartArrayToken()) {
String[] arr = handleNonArray(p, ctxt);
if (arr == null) {
return intoValue;
}
final int offset = intoValue.length;
String[] result = new String[offset + arr.length];
System.arraycopy(intoValue, 0, result, 0, offset);
System.arraycopy(arr, 0, result, offset, arr.length);
return result;
}
if (_elementDeserializer != null) {
return _deserializeCustom(p, ctxt, intoValue);
}
final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
int ix = intoValue.length;
Object[] chunk = buffer.resetAndStart(intoValue, ix);
try {
while (true) {
String value = p.nextTextValue();
if (value == null) {
JsonToken t = p.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
if (t != JsonToken.VALUE_NULL) {
value = _parseString(p, ctxt);
}
}
if (ix >= chunk.length) {
chunk = buffer.appendCompletedChunk(chunk);
ix = 0;
}
chunk[ix++] = value;
}
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, chunk, buffer.bufferedSize() + ix);
}
String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class);
ctxt.returnObjectBuffer(buffer);
return result;
}
public void testBinary() throws Exception {
ObjectMapper mapper = new ObjectMapper();
final int LENGTH = 13045;
byte[] data = new byte[LENGTH];
for (int i = 0; i < LENGTH; ++i) {
data[i] = (byte) i;
}
StringWriter sw = new StringWriter();
mapper.writeValue(sw, BinaryNode.valueOf(data));
JsonParser p = new JsonFactory().createParser(sw.toString());
// note: can't determine it's binary from json alone:
assertToken(JsonToken.VALUE_STRING, p.nextToken());
assertArrayEquals(data, p.getBinaryValue());
p.close();
}
@Override
public Leaf deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
JsonNode tree = (JsonNode) jp.readValueAsTree();
Leaf leaf = new Leaf();
leaf.value = tree.get("value").intValue();
return leaf;
}
private final String[] handleNonArray(JsonParser p, DeserializationContext ctxt)
throws IOException {
// implicit arrays from single values?
boolean canWrap =
(_unwrapSingle == Boolean.TRUE)
|| ((_unwrapSingle == null)
&& ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY));
if (canWrap) {
return new String[] {p.hasToken(JsonToken.VALUE_NULL) ? null : _parseString(p, ctxt)};
}
if (p.hasToken(JsonToken.VALUE_STRING)
&& ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
String str = p.getText();
if (str.length() == 0) {
return null;
}
}
return (String[]) ctxt.handleUnexpectedToken(_valueClass, p);
}
protected final double _testRawDeser(int reps, byte[] json, ObjectReader reader)
throws IOException {
long start = System.nanoTime();
final JsonFactory f = reader.getFactory();
while (--reps >= 0) {
JsonParser p = f.createParser(new ByteArrayInputStream(json));
JsonToken t;
while ((t = p.nextToken()) != null) {
if (t == JsonToken.VALUE_STRING) {
p.getText();
} else if (t.isNumeric()) {
p.getNumberValue();
}
;
}
p.close();
}
hash = f.hashCode();
return _msecsFromNanos(System.nanoTime() - start);
}
/**
* This method is needed by some specialized bean deserializers, and also called by some {@link
* #deserializeAndSet} implementations.
*
* <p>Pre-condition is that passed parser must point to the first token that should be consumed to
* produce the value (the only value for scalars, multiple for Objects and Arrays).
*
* <p>Note that this method is final for performance reasons: to override functionality you must
* override other methods that call this method; this method should also not be called directly
* unless you really know what you are doing (and probably not even then).
*/
public final Object deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
JsonToken t = jp.getCurrentToken();
if (t == JsonToken.VALUE_NULL) {
return (_nullProvider == null) ? null : _nullProvider.nullValue(ctxt);
}
if (_valueTypeDeserializer != null) {
return _valueDeserializer.deserializeWithType(jp, ctxt, _valueTypeDeserializer);
}
return _valueDeserializer.deserialize(jp, ctxt);
}
@Override
public JSONArray deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
JSONArray array = new JSONArray();
JsonToken t;
while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
switch (t) {
case START_ARRAY:
array.put(deserialize(jp, ctxt));
continue;
case START_OBJECT:
array.put(JSONObjectDeserializer.instance.deserialize(jp, ctxt));
continue;
case VALUE_STRING:
array.put(jp.getText());
continue;
case VALUE_NULL:
array.put(JSONObject.NULL);
continue;
case VALUE_TRUE:
array.put(Boolean.TRUE);
continue;
case VALUE_FALSE:
array.put(Boolean.FALSE);
continue;
case VALUE_NUMBER_INT:
array.put(jp.getNumberValue());
continue;
case VALUE_NUMBER_FLOAT:
array.put(jp.getNumberValue());
continue;
case VALUE_EMBEDDED_OBJECT:
array.put(jp.getEmbeddedObject());
continue;
}
throw ctxt.mappingException("Urecognized or unsupported JsonToken type: " + t);
}
return array;
}
@Override
public EnumMap<?, ?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
// Ok: must point to START_OBJECT
if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
return _deserializeFromEmpty(jp, ctxt);
}
EnumMap result = constructMap();
final JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
while ((jp.nextToken()) == JsonToken.FIELD_NAME) {
String keyName = jp.getCurrentName(); // just for error message
// but we need to let key deserializer handle it separately, nonetheless
Enum<?> key = (Enum<?>) _keyDeserializer.deserializeKey(keyName, ctxt);
if (key == null) {
if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
throw ctxt.weirdStringException(
keyName,
_enumClass,
"value not one of declared Enum instance names for " + _mapType.getKeyType());
}
/* 24-Mar-2012, tatu: Null won't work as a key anyway, so let's
* just skip the entry then. But we must skip the value as well, if so.
*/
jp.nextToken();
jp.skipChildren();
continue;
}
// And then the value...
JsonToken t = jp.nextToken();
/* note: MUST check for nulls separately: deserializers will
* not handle them (and maybe fail or return bogus data)
*/
Object value;
try {
if (t == JsonToken.VALUE_NULL) {
value = valueDes.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(jp, ctxt);
} else {
value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
}
} catch (Exception e) {
wrapAndThrow(e, result, keyName);
return null;
}
result.put(key, value);
}
return result;
}
private Collection<String> deserializeUsingCustom(
JsonParser jp,
DeserializationContext ctxt,
Collection<String> result,
final JsonDeserializer<String> deser)
throws IOException {
JsonToken t;
while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
String value;
if (t == JsonToken.VALUE_NULL) {
value = deser.getNullValue();
} else {
value = deser.deserialize(jp, ctxt);
}
result.add(value);
}
return result;
}
/**
* Helper method called when current token is no START_ARRAY. Will either throw an exception, or
* try to handle value as if member of implicit array, depending on configuration.
*/
private final Collection<String> handleNonArray(
JsonParser jp, DeserializationContext ctxt, Collection<String> result) throws IOException {
// [JACKSON-526]: implicit arrays from single values?
if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
throw ctxt.mappingException(_collectionType.getRawClass());
}
// Strings are one of "native" (intrinsic) types, so there's never type deserializer involved
JsonDeserializer<String> valueDes = _valueDeserializer;
JsonToken t = jp.getCurrentToken();
String value;
if (t == JsonToken.VALUE_NULL) {
value = (valueDes == null) ? null : valueDes.getNullValue();
} else {
value = (valueDes == null) ? _parseString(jp, ctxt) : valueDes.deserialize(jp, ctxt);
}
result.add(value);
return result;
}
@Override
public OffsetTime deserialize(JsonParser parser, DeserializationContext context)
throws IOException {
if (parser.hasToken(JsonToken.VALUE_STRING)) {
String string = parser.getText().trim();
if (string.length() == 0) {
return null;
}
try {
return OffsetTime.parse(string, _formatter);
} catch (DateTimeException e) {
_rethrowDateTimeException(parser, context, e, string);
}
}
if (!parser.isExpectedStartArrayToken()) {
if (parser.hasToken(JsonToken.VALUE_EMBEDDED_OBJECT)) {
return (OffsetTime) parser.getEmbeddedObject();
}
throw context.wrongTokenException(parser, JsonToken.START_ARRAY, "Expected array or string.");
}
int hour = parser.nextIntValue(-1);
if (hour == -1) {
JsonToken t = parser.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
return null;
}
if (t != JsonToken.VALUE_NUMBER_INT) {
_reportWrongToken(parser, context, JsonToken.VALUE_NUMBER_INT, "hours");
}
hour = parser.getIntValue();
}
int minute = parser.nextIntValue(-1);
if (minute == -1) {
JsonToken t = parser.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
return null;
}
if (t != JsonToken.VALUE_NUMBER_INT) {
_reportWrongToken(parser, context, JsonToken.VALUE_NUMBER_INT, "minutes");
}
minute = parser.getIntValue();
}
int partialSecond = 0;
int second = 0;
if (parser.nextToken() == JsonToken.VALUE_NUMBER_INT) {
second = parser.getIntValue();
if (parser.nextToken() == JsonToken.VALUE_NUMBER_INT) {
partialSecond = parser.getIntValue();
if (partialSecond < 1_000
&& !context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS)) {
partialSecond *= 1_000_000; // value is milliseconds, convert it to nanoseconds
}
parser.nextToken();
}
}
if (parser.getCurrentToken() == JsonToken.VALUE_STRING) {
OffsetTime t =
OffsetTime.of(hour, minute, second, partialSecond, ZoneOffset.of(parser.getText()));
if (parser.nextToken() != JsonToken.END_ARRAY) {
_reportWrongToken(parser, context, JsonToken.END_ARRAY, "timezone");
}
return t;
}
throw context.wrongTokenException(
parser, JsonToken.VALUE_STRING, "Expected string for TimeZone after numeric values");
}
private void verifyFromArray(String input) throws Exception {
JsonParser p = new JsonFactory().createParser(new StringReader(input));
assertEquals(JsonToken.START_ARRAY, p.nextToken());
assertEquals(JsonToken.VALUE_STRING, p.nextToken());
assertEquals(TEXT1, getAndVerifyText(p));
assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken());
assertEquals(3, p.getIntValue());
assertEquals(JsonToken.START_OBJECT, p.nextToken());
assertEquals(JsonToken.FIELD_NAME, p.nextToken());
assertEquals(FIELD1, getAndVerifyText(p));
assertEquals(JsonToken.VALUE_TRUE, p.nextToken());
assertEquals(JsonToken.FIELD_NAME, p.nextToken());
assertEquals(FIELD2, getAndVerifyText(p));
assertEquals(JsonToken.START_ARRAY, p.nextToken());
assertEquals(JsonToken.END_ARRAY, p.nextToken());
assertEquals(JsonToken.END_OBJECT, p.nextToken());
assertEquals(JsonToken.VALUE_FALSE, p.nextToken());
assertEquals(JsonToken.END_ARRAY, p.nextToken());
assertNull(p.nextToken());
p.close();
}
private void verifyFromMap(String input) throws Exception {
JsonParser p = new JsonFactory().createParser(input);
assertEquals(JsonToken.START_OBJECT, p.nextToken());
assertEquals(JsonToken.FIELD_NAME, p.nextToken());
assertEquals(FIELD4, getAndVerifyText(p));
assertEquals(JsonToken.VALUE_STRING, p.nextToken());
assertEquals(TEXT2, getAndVerifyText(p));
assertEquals(JsonToken.FIELD_NAME, p.nextToken());
assertEquals(FIELD3, getAndVerifyText(p));
assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken());
assertEquals(-1, p.getIntValue());
assertEquals(JsonToken.FIELD_NAME, p.nextToken());
assertEquals(FIELD2, getAndVerifyText(p));
assertEquals(JsonToken.START_ARRAY, p.nextToken());
assertEquals(JsonToken.END_ARRAY, p.nextToken());
assertEquals(JsonToken.FIELD_NAME, p.nextToken());
assertEquals(FIELD1, getAndVerifyText(p));
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken());
assertEquals(DOUBLE_VALUE, p.getDoubleValue(), 0);
assertEquals(JsonToken.END_OBJECT, p.nextToken());
assertNull(p.nextToken());
p.close();
}
@Override
public Record deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
JsonToken t = jp.getCurrentToken();
SimpleDateFormat sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss Z yyyy");
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
String id = null;
String type = null;
Date creationDate = null;
JsonToken currentToken = null;
Map<String, Field> fields = new HashMap<>();
boolean processingFields = false;
while ((currentToken = jp.nextValue()) != null) {
switch (currentToken) {
case START_OBJECT:
processingFields = true;
break;
case END_OBJECT:
processingFields = true;
break;
case VALUE_NUMBER_INT:
try {
fields.put(
jp.getCurrentName(),
new Field(jp.getCurrentName(), FieldType.INT, jp.getIntValue()));
} catch (JsonParseException ex) {
fields.put(
jp.getCurrentName(),
new Field(jp.getCurrentName(), FieldType.LONG, jp.getLongValue()));
}
break;
case VALUE_NUMBER_FLOAT:
try {
fields.put(
jp.getCurrentName(),
new Field(jp.getCurrentName(), FieldType.FLOAT, jp.getFloatValue()));
} catch (JsonParseException ex) {
fields.put(
jp.getCurrentName(),
new Field(jp.getCurrentName(), FieldType.DOUBLE, jp.getDoubleValue()));
}
break;
case VALUE_FALSE:
case VALUE_TRUE:
fields.put(
jp.getCurrentName(),
new Field(jp.getCurrentName(), FieldType.BOOLEAN, jp.getBooleanValue()));
break;
case START_ARRAY:
logger.info(jp.getCurrentName());
break;
case END_ARRAY:
break;
case VALUE_STRING:
if (jp.getCurrentName() != null) {
switch (jp.getCurrentName()) {
case "id":
id = jp.getValueAsString();
break;
case "type":
type = jp.getValueAsString();
break;
case "creationDate":
try {
creationDate =
sdf.parse(jp.getValueAsString()); // "Thu Sep 08 12:11:08 CEST 2016\"
} catch (ParseException e) {
e.printStackTrace();
}
break;
default:
fields.put(
jp.getCurrentName(),
new Field(jp.getCurrentName(), FieldType.STRING, jp.getValueAsString()));
break;
}
}
break;
default:
break;
}
}
Record record = new StandardRecord(type);
record.setId(id);
record.setType(type);
record.setTime(creationDate);
record.setFields(fields);
return record;
}
