JsonDeserializer<Object> contentDeser = contentType.getValueHandler(); final DeserializationConfig config = ctxt.getConfig(); TypeDeserializer contentTypeDeser = contentType.getTypeHandler(); if (!inst.canCreateUsingDefault()) { if (contentType.hasRawClass(String.class)) { deser = new CollectionDeserializer(type, contentDeser, contentTypeDeser, inst);
@SuppressWarnings("unchecked") @Override public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (_delegateDeserializer != null) { return (Collection<Object>) _valueInstantiator.createUsingDelegate(ctxt, _delegateDeserializer.deserialize(p, ctxt)); } // Empty String may be ok; bit tricky to check, however, since // there is also possibility of "auto-wrapping" of single-element arrays. // Hence we only accept empty String here. if (p.hasToken(JsonToken.VALUE_STRING)) { String str = p.getText(); if (str.length() == 0) { return (Collection<Object>) _valueInstantiator.createFromString(ctxt, str); } } return deserialize(p, ctxt, createDefaultInstance(ctxt)); }
delegateDeser = findDeserializer(ctxt, delegateType, property); } else if (_valueInstantiator.canCreateUsingArrayDelegate()) { JavaType delegateType = _valueInstantiator.getArrayDelegateType(ctxt.getConfig()); if (delegateType == null) { ctxt.reportBadDefinition(_containerType, String.format( _valueInstantiator.getClass().getName())); delegateDeser = findDeserializer(ctxt, delegateType, property); Boolean unwrapSingle = findFormatFeature(ctxt, property, Collection.class, JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY); valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser); final JavaType vt = _containerType.getContentType(); if (valueDeser == null) { valueDeser = ctxt.findContextualValueDeserializer(vt, property); valueTypeDeser = valueTypeDeser.forProperty(property); NullValueProvider nuller = findContentNullProvider(ctxt, property, valueDeser); if ( (unwrapSingle != _unwrapSingle) || (nuller != _nullProvider) || (valueTypeDeser != _valueTypeDeserializer) ) { return withResolved(delegateDeser, valueDeser, valueTypeDeser, nuller, unwrapSingle);
if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt, result); p.setCurrentValue(result); if (valueDes.getObjectIdReader() != null) { return _deserializeWithObjectId(p, ctxt, result); while ((t = p.nextToken()) != JsonToken.END_ARRAY) { try { Object value; value = valueDes.deserialize(p, ctxt); } else { value = valueDes.deserializeWithType(p, ctxt, typeDeser); boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS); if (!wrap) { ClassUtil.throwIfRTE(e);
if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt, result); p.setCurrentValue(result); new CollectionReferringAccumulator(_containerType.getContentType().getRawClass(), result); while ((t = p.nextToken()) != JsonToken.END_ARRAY) { try { Object value; value = valueDes.deserialize(p, ctxt); } else { value = valueDes.deserializeWithType(p, ctxt, typeDeser); reference.getRoid().appendReferring(ref); } catch (Exception e) { boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS); if (!wrap) { ClassUtil.throwIfRTE(e);
@SuppressWarnings("unchecked") @Override public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (_delegateDeserializer != null) { return (Collection<Object>) _valueInstantiator.createUsingDelegate(ctxt, _delegateDeserializer.deserialize(p, ctxt)); } /* [JACKSON-620]: empty String may be ok; bit tricky to check, however, since * there is also possibility of "auto-wrapping" of single-element arrays. * Hence we only accept empty String here. */ if (p.getCurrentToken() == JsonToken.VALUE_STRING) { String str = p.getText(); if (str.length() == 0) { return (Collection<Object>) _valueInstantiator.createFromString(ctxt, str); } } return deserialize(p, ctxt, (Collection<Object>) _valueInstantiator.createUsingDefault(ctxt)); }
@Override public Collection<Object> deserialize(JsonParser jp, DeserializationContext ctxt, Collection<Object> result) throws IOException, JsonProcessingException { // Ok: must point to START_ARRAY (or equivalent) if (!jp.isExpectedStartArrayToken()) { return handleNonArray(jp, ctxt, result); } JsonDeserializer<Object> valueDes = _valueDeserializer; JsonToken t; final TypeDeserializer typeDeser = _valueTypeDeserializer; while ((t = jp.nextToken()) != JsonToken.END_ARRAY) { Object value; if (t == JsonToken.VALUE_NULL) { value = null; } else if (typeDeser == null) { value = valueDes.deserialize(jp, ctxt); } else { value = valueDes.deserializeWithType(jp, ctxt, typeDeser); } result.add(value); } return result; }
@SuppressWarnings("unchecked") @Override public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (_delegateDeserializer != null) { return (Collection<Object>) _valueInstantiator.createUsingDelegate(ctxt, _delegateDeserializer.deserialize(p, ctxt)); } /* Empty String may be ok; bit tricky to check, however, since * there is also possibility of "auto-wrapping" of single-element arrays. * Hence we only accept empty String here. */ if (p.hasToken(JsonToken.VALUE_STRING)) { String str = p.getText(); if (str.length() == 0) { return (Collection<Object>) _valueInstantiator.createFromString(ctxt, str); } } return deserialize(p, ctxt, (Collection<Object>) _valueInstantiator.createUsingDefault(ctxt)); }
JsonDeserializer<Object> contentDeser = contentType.getValueHandler(); TypeDeserializer contentTypeDeser = contentType.getTypeHandler(); contentTypeDeser = findTypeDeserializer(ctxt.getConfig(), contentType); ctxt.getConfig(), beanDesc, contentTypeDeser, contentDeser); if (custom != null) { return custom; type = (CollectionType) ctxt.getConfig().constructSpecializedType(type, collectionClass); beanDesc = ctxt.getConfig().introspectForCreation(type); if (contentType.getRawClass() == String.class) { return new CollectionDeserializer(type, contentDeser, contentTypeDeser, inst);
if ((_valueInstantiator != null) && _valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'"); delegateDeser = findDeserializer(ctxt, delegateType, property); valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser); 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); return withResolved(delegateDeser, valueDeser, valueTypeDeser);
if ((_valueInstantiator != null) && _valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'"); delegateDeser = findDeserializer(ctxt, delegateType, property); valueDeser = ctxt.findContextualValueDeserializer( _collectionType.getContentType(), property); } else { // if directly assigned, probably not yet contextual, so: if (valueDeser instanceof ContextualDeserializer) { valueTypeDeser = valueTypeDeser.forProperty(property); return withResolved(delegateDeser, valueDeser, valueTypeDeser);
@Override public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt, Collection<Object> result0) throws IOException { if (result0 != null) { return super.deserialize(p, ctxt, result0); } // Ok: must point to START_ARRAY (or equivalent) if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt, new ArrayBlockingQueue<Object>(1)); } result0 = super.deserialize(p, ctxt, new ArrayList<Object>()); return new ArrayBlockingQueue<Object>(result0.size(), false, result0); }
/** * Fluent-factory method call to construct contextual instance. * * @since 2.9 */ @SuppressWarnings("unchecked") protected CollectionDeserializer withResolved(JsonDeserializer<?> dd, JsonDeserializer<?> vd, TypeDeserializer vtd, NullValueProvider nuller, Boolean unwrapSingle) { //if (true) throw new Error(); return new CollectionDeserializer(_containerType, (JsonDeserializer<Object>) vd, vtd, _valueInstantiator, (JsonDeserializer<Object>) dd, nuller, unwrapSingle); }
/** * @deprecated Since 2.7 as it does not pass `unwrapSingle` */ @Deprecated // since 2.7 -- will not retain "unwrapSingle" setting protected CollectionDeserializer withResolved(JsonDeserializer<?> dd, JsonDeserializer<?> vd, TypeDeserializer vtd) { return withResolved(dd, vd, vtd, _unwrapSingle); }
if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt, result); p.setCurrentValue(result); (valueDes.getObjectIdReader() == null) ? null : new CollectionReferringAccumulator(_collectionType.getContentType().getRawClass(), result); while ((t = p.nextToken()) != JsonToken.END_ARRAY) { try { Object value; if (t == JsonToken.VALUE_NULL) { value = valueDes.getNullValue(ctxt); } else if (typeDeser == null) { value = valueDes.deserialize(p, ctxt); } else { value = valueDes.deserializeWithType(p, ctxt, typeDeser); reference.getRoid().appendReferring(ref); } catch (Exception e) { boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS); if (!wrap && e instanceof RuntimeException) { throw (RuntimeException)e;
@SuppressWarnings("unchecked") @Override public Collection<Object> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { if (_delegateDeserializer != null) { return (Collection<Object>) _valueInstantiator.createUsingDelegate(ctxt, _delegateDeserializer.deserialize(jp, ctxt)); } /* [JACKSON-620]: empty String may be ok; bit tricky to check, however, since * there is also possibility of "auto-wrapping" of single-element arrays. * Hence we only accept empty String here. */ if (jp.getCurrentToken() == JsonToken.VALUE_STRING) { String str = jp.getText(); if (str.length() == 0) { return (Collection<Object>) _valueInstantiator.createFromString(ctxt, str); } } return deserialize(jp, ctxt, (Collection<Object>) _valueInstantiator.createUsingDefault(ctxt)); }
if (!p.isExpectedStartArrayToken()) { return handleNonArray(p, ctxt, result); p.setCurrentValue(result); if (valueDes.getObjectIdReader() != null) { return _deserializeWithObjectId(p, ctxt, result); while ((t = p.nextToken()) != JsonToken.END_ARRAY) { try { Object value; value = valueDes.deserialize(p, ctxt); } else { value = valueDes.deserializeWithType(p, ctxt, typeDeser); boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS); if (!wrap) { ClassUtil.throwIfRTE(e);
@Override public Collection<Object> deserialize(JsonParser jp, DeserializationContext ctxt, Collection<Object> result) throws IOException, JsonProcessingException { // Ok: must point to START_ARRAY (or equivalent) if (!jp.isExpectedStartArrayToken()) { return handleNonArray(jp, ctxt, result); } JsonDeserializer<Object> valueDes = _valueDeserializer; JsonToken t; final TypeDeserializer typeDeser = _valueTypeDeserializer; while ((t = jp.nextToken()) != JsonToken.END_ARRAY) { Object value; if (t == JsonToken.VALUE_NULL) { value = null; } else if (typeDeser == null) { value = valueDes.deserialize(jp, ctxt); } else { value = valueDes.deserializeWithType(jp, ctxt, typeDeser); } result.add(value); } return result; }
JsonDeserializer<Object> contentDeser = contentType.getValueHandler(); TypeDeserializer contentTypeDeser = contentType.getTypeHandler(); contentTypeDeser = findTypeDeserializer(ctxt.getConfig(), contentType); ctxt.getConfig(), beanDesc, contentTypeDeser, contentDeser); if (custom != null) { return custom; type = (CollectionType) ctxt.getConfig().constructSpecializedType(type, collectionClass); beanDesc = ctxt.getConfig().introspectForCreation(type); if (contentType.getRawClass() == String.class) { return new CollectionDeserializer(type, contentDeser, contentTypeDeser, inst);
if ((_valueInstantiator != null) && _valueInstantiator.canCreateUsingDelegate()) { JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig()); if (delegateType == null) { throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'"); delegateDeser = findDeserializer(ctxt, delegateType, property); valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser); 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); return withResolved(delegateDeser, valueDeser, valueTypeDeser);