TypeDeserializer typeDeserializer) throws IOException switch (p.getCurrentTokenId()) { case JsonTokenId.ID_FIELD_NAME: return typeDeserializer.deserializeTypedFromAny(p, ctxt); 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 _numberDeserializer.deserialize(p, ctxt); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return p.getDecimalValue(); default: return ctxt.handleUnexpectedToken(Object.class, p);
if (p.canReadObjectId()) { Object id = p.getObjectId(); if (id != null) { Object ob = typeDeserializer.deserializeTypedFromObject(p, ctxt); return _handleTypedObjectId(p, ctxt, ob, id); JsonToken t = p.getCurrentToken(); if (t != null) { if (t.isScalarValue()) { return deserializeFromObjectId(p, ctxt); return typeDeserializer.deserializeTypedFromObject(p, ctxt);
@Override public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException { // In future could check current token... for now this should be enough: return typeDeserializer.deserializeTypedFromArray(p, ctxt); }
/** * Specialized called when we need to expose type id of `defaultImpl` when * serializing: we may need to expose it for assignment to a property, or * it may be requested as visible for some other reason. */ public String getDefaultTypeId() { Class<?> defaultType = _typeDeserializer.getDefaultImpl(); if (defaultType == null) { return null; } return _typeDeserializer.getTypeIdResolver().idFromValueAndType(null, defaultType); }
@Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException JsonToken t = jp.getCurrentToken(); switch (t) { return typeDeserializer.deserializeTypedFromAny(jp, ctxt); return _stringDeserializer.deserialize(jp, ctxt); return jp.getText(); return _numberDeserializer.deserialize(jp, ctxt); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); return _numberDeserializer.deserialize(jp, ctxt); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); return null; default: throw ctxt.mappingException(Object.class);
JsonToken t = p.getCurrentToken(); if (t != null) { if (t.isScalarValue()) { return _deserializeFromObjectId(p, ctxt); t = p.nextToken(); && _objectIdReader.isValidReferencePropertyName(p.getCurrentName(), p)) { return _deserializeFromObjectId(p, ctxt); return result; return typeDeserializer.deserializeTypedFromObject(p, ctxt);
throws IOException, JsonProcessingException JsonToken t = jp.getCurrentToken(); switch (t) { return typeDeserializer.deserializeTypedFromAny(jp, ctxt); return jp.getText(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); return jp.getIntValue(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); return null; throw ctxt.mappingException(Object.class);
@Override public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException switch (p.getCurrentTokenId()) { case JsonTokenId.ID_START_ARRAY: case JsonTokenId.ID_START_OBJECT: case JsonTokenId.ID_FIELD_NAME: return typeDeserializer.deserializeTypedFromAny(p, ctxt); return p.getText(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return p.getBigIntegerValue(); return p.getNumberValue(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return p.getDecimalValue(); default: return ctxt.handleUnexpectedToken(Object.class, p);
@Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException switch (jp.getCurrentTokenId()) { case JsonTokenId.ID_START_ARRAY: case JsonTokenId.ID_START_OBJECT: case JsonTokenId.ID_FIELD_NAME: return typeDeserializer.deserializeTypedFromAny(jp, ctxt); return jp.getText(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) { return jp.getBigIntegerValue(); return jp.getNumberValue(); if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) { return jp.getDecimalValue(); return null; default: throw ctxt.mappingException(Object.class);
@Override public Object deserializeWithType(JsonParser parser, DeserializationContext context, TypeDeserializer deserializer) throws IOException { /** * This is a nasty kludge right here, working around issues like * [datatype-jsr310#24]. But should work better than not having the work-around. */ if (parser.getCurrentToken().isScalarValue()) { return deserialize(parser, context); } return deserializer.deserializeTypedFromAny(parser, context); } }
@Override public final Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { /* 16-Feb-2012, tatu: ObjectId may be used as well... need to check * that first */ if (_objectIdReader != null) { JsonToken t = jp.getCurrentToken(); // should be good enough check; we only care about Strings, integral numbers: if (t != null && t.isScalarValue()) { return deserializeFromObjectId(jp, ctxt); } } // In future could check current token... for now this should be enough: return typeDeserializer.deserializeTypedFromObject(jp, ctxt); }
protected Object mapObject(JsonParser p, DeserializationContext ctxt) throws IOException { Object key1; JsonToken t = p.currentToken(); key1 = p.nextFieldName(); } else if (t == JsonToken.FIELD_NAME) { key1 = p.currentName(); } else { if (t != JsonToken.END_OBJECT) { return ctxt.handleUnexpectedToken(handledType(), p); if (p.getTypeId() != null) { if (_typeDeserializer != null) { TypeIdResolver idResolver = _typeDeserializer.getTypeIdResolver(); JavaType keyType = idResolver.typeFromId(ctxt, p.getTypeId().toString()); if (keyType != null) { deserializer = ctxt.findKeyDeserializer(keyType, null);
@Override public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException { final JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_NULL) { // can this actually happen? return getNullValue(ctxt); } // 22-Oct-2015, tatu: This handling is probably not needed (or is wrong), but // could be result of older (pre-2.7) Jackson trying to serialize natural types. // Because of this, let's allow for now, unless proven problematic /* if ((t != null) && t.isScalarValue()) { return deserialize(p, ctxt); } */ // 19-Apr-2016, tatu: Alas, due to there typically really being anything for Reference wrapper // itself, need to just ignore `typeDeser`, use TypeDeserializer we do have for contents // and it might just work. if (_valueTypeDeserializer == null) { return deserialize(p, ctxt); } return referenceValue(_valueTypeDeserializer.deserializeTypedFromAny(p, ctxt)); } }
/** * As mentioned in class Javadoc, there is additional complexity in * handling potentially mixed type information here. Because of this, * we must actually check for "raw" integers and doubles first, before * calling type deserializer. */ @Override public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { switch (jp.getCurrentToken()) { case VALUE_NUMBER_INT: case VALUE_NUMBER_FLOAT: case VALUE_STRING: // can not point to type information: hence must be non-typed (int/double) return deserialize(jp, ctxt); } return typeDeserializer.deserializeTypedFromScalar(jp, ctxt); } }
@Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { JsonDeserializer<?> valueDeser = _elementDeserializer; Boolean unwrapSingle = findFormatFeature(ctxt, property, _containerType.getRawClass(), JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY); // May have a content converter valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser); final JavaType vt = _containerType.getContentType(); if (valueDeser == null) { valueDeser = ctxt.findContextualValueDeserializer(vt, property); } else { // if directly assigned, probably not yet contextual, so: valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, vt); } TypeDeserializer elemTypeDeser = _elementTypeDeserializer; if (elemTypeDeser != null) { elemTypeDeser = elemTypeDeser.forProperty(property); } NullValueProvider nuller = findContentNullProvider(ctxt, property, valueDeser); return withResolved(elemTypeDeser, valueDeser, nuller, unwrapSingle); }
if (_valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { ctxt.reportBadDefinition(_containerType, String.format( "Invalid delegate-creator definition for %s: value instantiator (%s) returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'", _containerType, } else if (_valueInstantiator.canCreateUsingArrayDelegate()) { JavaType delegateType = _valueInstantiator.getArrayDelegateType(ctxt.getConfig()); if (delegateType == null) { ctxt.reportBadDefinition(_containerType, String.format( final JavaType vt = _containerType.getContentType(); if (valueDeser == null) { valueDeser = ctxt.findContextualValueDeserializer(vt, property); valueTypeDeser = valueTypeDeser.forProperty(property);
if (_valueInstantiator.canCreateFromObjectWith()) { creatorProps = _valueInstantiator.getFromObjectArguments(ctxt.getConfig()); for (int i = 0, end = creatorProps.length; i < end; ++i) { SettableBeanProperty prop = creatorProps[i]; if (_ignorableProps.contains(prop.getName())) { creatorProps[i].markAsIgnorable(); if (!prop.hasValueDeserializer()) { deser = ctxt.findNonContextualValueDeserializer(prop.getType()); SettableBeanProperty newProp = prop.withValueDeserializer(deser); SettableBeanProperty prop = origProp; JsonDeserializer<?> deser = prop.getValueDeserializer(); deser = ctxt.handlePrimaryContextualization(deser, prop, prop.getType()); prop = prop.withValueDeserializer(deser); if (prop.hasValueTypeDeserializer()) { TypeDeserializer typeDeser = prop.getValueTypeDeserializer(); if (typeDeser.getTypeInclusion() == JsonTypeInfo.As.EXTERNAL_PROPERTY) { if (extTypes == null) { extTypes = ExternalTypeHandler.builder(_beanType); if (_valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) {
if ((_valueInstantiator != null) && _valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType final JavaType vt = _collectionType.getContentType(); if (valueDeser == null) { valueDeser = ctxt.findContextualValueDeserializer(vt, property); } else { // if directly assigned, probably not yet contextual, so: valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, vt); valueTypeDeser = valueTypeDeser.forProperty(property);
if (_valueInstantiator.canCreateFromObjectWith()) { SettableBeanProperty[] creatorProps = _valueInstantiator.getFromObjectArguments(ctxt.getConfig()); _propertyBasedCreator = PropertyBasedCreator.construct(ctxt, _valueInstantiator, creatorProps); if (prop.hasValueTypeDeserializer()) { TypeDeserializer typeDeser = prop.getValueTypeDeserializer(); if (typeDeser.getTypeInclusion() == JsonTypeInfo.As.EXTERNAL_PROPERTY) { if (extTypes == null) { extTypes = new ExternalTypeHandler.Builder(); SettableBeanProperty prop = origProp; if (!prop.hasValueDeserializer()) { JsonDeserializer<?> cd = ctxt.handlePrimaryContextualization(deser, prop, prop.getType()); if (cd != deser) { if (prop.hasValueTypeDeserializer()) { TypeDeserializer typeDeser = prop.getValueTypeDeserializer(); if (typeDeser.getTypeInclusion() == JsonTypeInfo.As.EXTERNAL_PROPERTY) { if (extTypes == null) { extTypes = new ExternalTypeHandler.Builder(); PropertyMetadata.STD_OPTIONAL); td = td.forProperty(property); dd = new TypeWrappedDeserializer(td, dd);
/** * Method called to finalize setup of this deserializer, * when it is known for which property deserializer is needed for. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { // note: instead of finding key deserializer, with enums we actually // work with regular deserializers (less code duplication; but not // quite as clean as it ought to be) KeyDeserializer keyDeser = _keyDeserializer; if (keyDeser == null) { keyDeser = ctxt.findKeyDeserializer(_containerType.getKeyType(), property); } JsonDeserializer<?> valueDeser = _valueDeserializer; final JavaType vt = _containerType.getContentType(); if (valueDeser == null) { valueDeser = ctxt.findContextualValueDeserializer(vt, property); } else { // if directly assigned, probably not yet contextual, so: valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, vt); } TypeDeserializer vtd = _valueTypeDeserializer; if (vtd != null) { vtd = vtd.forProperty(property); } return withResolved(keyDeser, valueDeser, vtd, findContentNullProvider(ctxt, property, valueDeser)); }