protected Object mapObject(JsonParser p, DeserializationContext ctxt, Map<Object,Object> m) throws IOException { JsonToken t = p.getCurrentToken(); if (t == JsonToken.START_OBJECT) { t = p.nextToken(); } if (t == JsonToken.END_OBJECT) { return m; } // NOTE: we are guaranteed to point to FIELD_NAME String key = p.getCurrentName(); do { p.nextToken(); // and possibly recursive merge here Object old = m.get(key); Object newV; if (old != null) { newV = deserialize(p, ctxt, old); } else { newV = deserialize(p, ctxt); } if (newV != old) { m.put(key, newV); } } while ((key = p.nextFieldName()) != null); return m; }
return deserialize(p, ctxt); return _mapDeserializer.deserialize(p, ctxt, intoValue); return mapObject(p, ctxt, (Map<Object,Object>) intoValue); return mapObject(p, ctxt); case JsonTokenId.ID_START_ARRAY: if (_listDeserializer != null) { return _listDeserializer.deserialize(p, ctxt, intoValue); return mapArray(p, ctxt, (Collection<Object>) intoValue); if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) { return mapArrayToArray(p, ctxt); return mapArray(p, ctxt); case JsonTokenId.ID_EMBEDDED_OBJECT: return p.getEmbeddedObject(); case JsonTokenId.ID_STRING: if (_stringDeserializer != null) { return _stringDeserializer.deserialize(p, ctxt, intoValue); if (ctxt.hasSomeOfFeatures(F_MASK_INT_COERCIONS)) { return _coerceIntegral(p, ctxt); return deserialize(p, ctxt);
DeserializationConfig config = ctxt.getConfig(); JavaType lt, mt; lt = mt = null; return new UntypedObjectDeserializer(lt, mt); TypeFactory tf = ctxt.getTypeFactory(); JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE); JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0]; CollectionType ct = tf.constructCollectionType(Collection.class, elemType); TypeDeserializer vts = (TypeDeserializer) vt.getTypeHandler(); if (vts == null) { vts = findTypeDeserializer(ctxt.getConfig(), vt);
public void resolve(DeserializationContext ctxt) throws JsonMappingException JavaType obType = ctxt.constructType(Object.class); JavaType stringType = ctxt.constructType(String.class); TypeFactory tf = ctxt.getTypeFactory(); _listDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructCollectionType(List.class, obType))); } else { _listDeserializer = _findCustomDeser(ctxt, _listType); _mapDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructMapType(Map.class, stringType, obType))); } else { _mapDeserializer = _findCustomDeser(ctxt, _mapType); _stringDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, stringType)); _numberDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructType(Number.class)));
JsonToken t = p.getCurrentToken(); key1 = p.nextFieldName(); } else if (t == JsonToken.FIELD_NAME) { key1 = p.getCurrentName(); } else { if (t != JsonToken.END_OBJECT) { return ctxt.handleUnexpectedToken(handledType(), p); p.nextToken(); Object value1 = deserialize(p, ctxt); String key2 = p.nextFieldName(); p.nextToken(); Object value2 = deserialize(p, ctxt); String key = p.nextFieldName(); p.nextToken(); result.put(key, deserialize(p, ctxt)); } while ((key = p.nextFieldName()) != null); return result;
throws IOException, JsonProcessingException switch (jp.getCurrentToken()) { case START_OBJECT: return mapObject(jp, ctxt); case END_OBJECT: // invalid break; case START_ARRAY: return mapArray(jp, ctxt); case END_ARRAY: // invalid break; case FIELD_NAME: return mapObject(jp, ctxt); case VALUE_EMBEDDED_OBJECT: return jp.getEmbeddedObject(); case VALUE_STRING: return jp.getText(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); // should be optimal, whatever it is if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); throw ctxt.mappingException(Object.class);
throws IOException, JsonProcessingException JsonToken t = jp.getCurrentToken(); if (t == JsonToken.START_OBJECT) { t = jp.nextToken(); String field1 = jp.getText(); jp.nextToken(); Object value1 = deserialize(jp, ctxt); if (jp.nextToken() != JsonToken.FIELD_NAME) { // single entry; but we want modifiable LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4); String field2 = jp.getText(); jp.nextToken(); Object value2 = deserialize(jp, ctxt); if (jp.nextToken() != JsonToken.FIELD_NAME) { LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4); String fieldName = jp.getText(); jp.nextToken(); result.put(fieldName, deserialize(jp, ctxt)); } while (jp.nextToken() != JsonToken.END_OBJECT); return result;
if (p.nextToken() == JsonToken.END_ARRAY) { return new ArrayList<Object>(2); Object value = deserialize(p, ctxt); if (p.nextToken() == JsonToken.END_ARRAY) { ArrayList<Object> l = new ArrayList<Object>(2); l.add(value); return l; Object value2 = deserialize(p, ctxt); if (p.nextToken() == JsonToken.END_ARRAY) { ArrayList<Object> l = new ArrayList<Object>(2); l.add(value); return l; ObjectBuffer buffer = ctxt.leaseObjectBuffer(); Object[] values = buffer.resetAndStart(); int ptr = 0; int totalSize = ptr; do { value = deserialize(p, ctxt); ++totalSize; if (ptr >= values.length) {
TypeDeserializer typeDeserializer) throws IOException switch (p.getCurrentTokenId()) { return p.getEmbeddedObject(); return _stringDeserializer.deserialize(p, ctxt); return p.getText(); return _numberDeserializer.deserialize(p, ctxt); if (ctxt.hasSomeOfFeatures(F_MASK_INT_COERCIONS)) { return _coerceIntegral(p, ctxt); return p.getNumberValue(); // should be optimal, whatever it is return _numberDeserializer.deserialize(p, ctxt); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return p.getDecimalValue(); default: return ctxt.handleUnexpectedToken(Object.class, p);
final TreeNode readTree = jp.getCodec().readTree(jp); final String typesNodeName = "@types"; final TreeNode typesNodes = readTree.get(typesNodeName); final TreeNode fieldNode = readTree.get(key); final JsonParser fieldValueParser = fieldNode.traverse(); fieldValueParser.setCodec(jp.getCodec()); JsonToken nextToken = fieldValueParser.nextToken(); if (targetType != null) { final Object o = getContextualValueDeserializer(targetType, ctxt) .deserialize(fieldValueParser, ctxt); collection.add(o); } else { collection.add(primitiveDeserializer.deserialize(fieldValueParser, ctxt)); if (targetType != null && targetType[0] != null) { final Object o = getContextualValueDeserializer(targetType[0], ctxt) .deserialize(fieldValueParser, ctxt); fields.put(key, o); } else { fields.put(key, primitiveDeserializer.deserialize(fieldValueParser, ctxt));
throws IOException, JsonProcessingException if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) { return mapArrayToArray(jp, ctxt); if (jp.nextToken() == JsonToken.END_ARRAY) { return new ArrayList<Object>(4); ObjectBuffer buffer = ctxt.leaseObjectBuffer(); Object[] values = buffer.resetAndStart(); int ptr = 0; int totalSize = 0; do { Object value = deserialize(jp, ctxt); ++totalSize; if (ptr >= values.length) { } while (jp.nextToken() != JsonToken.END_ARRAY);
protected Object mapArray(JsonParser p, DeserializationContext ctxt, Collection<Object> result) throws IOException { // we start by pointing to START_ARRAY. Also, no real merging; array/Collection // just appends always while (p.nextToken() != JsonToken.END_ARRAY) { result.add(deserialize(p, ctxt)); } return result; }
JsonParser jp, DeserializationContext ctxt) throws IOException { if (jp.getCurrentTokenId() != JsonTokenId.ID_START_OBJECT) { return super.deserialize(jp, ctxt); ObjectCodec codec = jp.getCodec(); TreeNode treeNode = codec.readTree(jp); Class<? extends Object> objectClass = null; return super.deserialize(codec.treeAsTokens(treeNode), ctxt);
@Override /** * All joynr objects are serialized with type information, so deserialize them as such */ public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonToken t = jp.getCurrentToken(); if (t == JsonToken.START_OBJECT) { return super.deserializeWithType(jp, ctxt, typeDeserializer); } return super.deserialize(jp, ctxt); } }
@Override public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { // Make sure we have a native type ID *AND* that we can resolve it to a type; otherwise, we'll end up in a recursive loop if (p.canReadTypeId()) { Object typeId = p.getTypeId(); if (typeId != null) { if (_typeDeserializer != null) { TypeIdResolver resolver = _typeDeserializer.getTypeIdResolver(); if (resolver != null && resolver.typeFromId(ctxt, typeId.toString()) != null) { return _typeDeserializer.deserializeTypedFromAny(p, ctxt); } } } } return super.deserialize(p, ctxt); }
/** * We only use contextualization for optimizing the case where no customization * occurred; if so, can slip in a more streamlined version. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { // 14-Jun-2017, tatu: [databind#1625]: may want to block merging, for root value boolean preventMerge = (property == null) && Boolean.FALSE.equals(ctxt.getConfig().getDefaultMergeable(Object.class)); // 20-Apr-2014, tatu: If nothing custom, let's use "vanilla" instance, // simpler and can avoid some of delegation if ((_stringDeserializer == null) && (_numberDeserializer == null) && (_mapDeserializer == null) && (_listDeserializer == null) && getClass() == UntypedObjectDeserializer.class) { return Vanilla.instance(preventMerge); } if (preventMerge != _nonMerging) { return new UntypedObjectDeserializer(this, preventMerge); } return this; }
protected JsonDeserializer<?> _withResolved(JsonDeserializer<?> mapDeser, JsonDeserializer<?> listDeser, JsonDeserializer<?> stringDeser, JsonDeserializer<?> numberDeser) { return new UntypedObjectDeserializer(this, mapDeser, listDeser, stringDeser, numberDeser); }
throws IOException, JsonProcessingException switch (jp.getCurrentToken()) { case START_OBJECT: return mapObject(jp, ctxt); case END_OBJECT: // invalid break; case START_ARRAY: return mapArray(jp, ctxt); case END_ARRAY: // invalid break; case FIELD_NAME: return mapObject(jp, ctxt); case VALUE_EMBEDDED_OBJECT: return jp.getEmbeddedObject(); case VALUE_STRING: return jp.getText(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); // should be optimal, whatever it is if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); throw ctxt.mappingException(Object.class);
JsonToken t = p.getCurrentToken(); key1 = p.nextFieldName(); } else if (t == JsonToken.FIELD_NAME) { key1 = p.getCurrentName(); } else { if (t != JsonToken.END_OBJECT) { return ctxt.handleUnexpectedToken(handledType(), p); p.nextToken(); Object value1 = deserialize(p, ctxt); String key2 = p.nextFieldName(); p.nextToken(); Object value2 = deserialize(p, ctxt); String key = p.nextFieldName(); p.nextToken(); result.put(key, deserialize(p, ctxt)); } while ((key = p.nextFieldName()) != null); return result;
throws IOException, JsonProcessingException JsonToken t = jp.getCurrentToken(); if (t == JsonToken.START_OBJECT) { t = jp.nextToken(); String field1 = jp.getText(); jp.nextToken(); Object value1 = deserialize(jp, ctxt); if (jp.nextToken() != JsonToken.FIELD_NAME) { // single entry; but we want modifiable LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4); String field2 = jp.getText(); jp.nextToken(); Object value2 = deserialize(jp, ctxt); if (jp.nextToken() != JsonToken.FIELD_NAME) { LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4); String fieldName = jp.getText(); jp.nextToken(); result.put(fieldName, deserialize(jp, ctxt)); } while (jp.nextToken() != JsonToken.END_OBJECT); return result;