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); throw JsonMappingException.wrapWithPath(e, result, result.size());
@Override public Object deserializeSetAndReturn(JsonParser p, DeserializationContext ctxt, Object instance) throws IOException { /* 02-Apr-2015, tatu: Actually, as per [databind#742], let it be; * missing or null id is needed for some cases, such as cases where id * will be generated externally, at a later point, and is not available * quite yet. Typical use case is with DB inserts. */ // note: no null checks (unlike usually); deserializer should fail if one found if (p.hasToken(JsonToken.VALUE_NULL)) { return null; } Object id = _valueDeserializer.deserialize(p, ctxt); ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver); roid.bindItem(instance); // also: may need to set a property value as well SettableBeanProperty idProp = _objectIdReader.idProperty; if (idProp != null) { return idProp.setAndReturn(instance, id); } return instance; }
/** * Overridable factory method to create a new instance of ReadableObjectId or its * subclass. It is meant to be overridden when custom ReadableObjectId is * needed for {@link #tryToResolveUnresolvedObjectId}. * Default implementation simply constructs default {@link ReadableObjectId} with * given <code>key</code>. * * @param key The key to associate with the new ReadableObjectId * @return New ReadableObjectId instance * * @since 2.7 */ protected ReadableObjectId createReadableObjectId(IdKey key) { return new ReadableObjectId(key); }
for (Entry<IdKey,ReadableObjectId> entry : _objectIds.entrySet()) { ReadableObjectId roid = entry.getValue(); if (!roid.hasReferringProperties()) { continue; exception = new UnresolvedForwardReference(getParser(), "Unresolved forward references for: "); Object key = roid.getKey().key; for (Iterator<Referring> iterator = roid.referringProperties(); iterator.hasNext(); ) { Referring referring = iterator.next(); exception.addUnresolvedId(key, referring.getBeanType(), referring.getLocation());
JsonProcessingException { ObjectIdGenerator<Integer> idGenerator = new ObjectIdGenerators.IntSequenceGenerator(); JsonLocation start = jp.getCurrentLocation(); JsonToken t = jp.getCurrentToken(); LogicalOperator parent = null; LogicalOperator first = null; String fieldName = jp.getText(); t = jp.nextToken(); switch (fieldName) { // switch on field names. break; case "input": JavaType tp = ctxt.constructType(LogicalOperator.class); JsonDeserializer<Object> d = ctxt.findRootValueDeserializer(tp); parent = (LogicalOperator) d.deserialize(jp, ctxt); break; ReadableObjectId rid = ctxt.findObjectId(id, idGenerator, null); rid.bindItem(prev);
if (p.hasTokenId(JsonTokenId.ID_FIELD_NAME)) { String propertyName = p.getCurrentName(); do { p.nextToken(); SettableBeanProperty property = _beanProperties.find(propertyName); Object id = property.deserialize(p, ctxt); ReadableObjectId objectId = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver); bean = objectId == null ? null : objectId.resolve(); if (bean == null) { bean = _valueInstantiator.createUsingDefault(ctxt); property.set(bean, id); p.setCurrentValue(bean); property.deserializeAndSet(p, ctxt, bean); } while ((propertyName = p.nextFieldName()) != null);
@Override public Object deserializeSetAndReturn(JsonParser p, DeserializationContext ctxt, Object instance) throws IOException { try { return setAndReturn(instance, deserialize(p, ctxt)); } catch (UnresolvedForwardReference reference) { boolean usingIdentityInfo = (_objectIdInfo != null) || (_valueDeserializer.getObjectIdReader() != null); if (!usingIdentityInfo) { throw JsonMappingException.from(p, "Unresolved forward reference but no identity info", reference); } reference.getRoid().appendReferring(new PropertyReferring(this, reference, _type.getRawClass(), instance)); return null; } }
/** * Method called in cases where it looks like we got an Object Id * to parse and use as a reference. */ protected Object deserializeFromObjectId(JsonParser p, DeserializationContext ctxt) throws IOException { Object id = _objectIdReader.readObjectReference(p, ctxt); ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver); // do we have it resolved? Object pojo = roid.resolve(); if (pojo == null) { // not yet; should wait... throw new UnresolvedForwardReference(p, "Could not resolve Object Id ["+id+"] (for "+_beanType+").", p.getCurrentLocation(), roid); } return pojo; }
/** * Helper method called to handle Object Id value collected earlier, if any */ public Object handleIdValue(final DeserializationContext ctxt, Object bean) throws IOException { if (_objectIdReader != null) { if (_idValue != null) { ReadableObjectId roid = ctxt.findObjectId(_idValue, _objectIdReader.generator, _objectIdReader.resolver); roid.bindItem(bean); // also: may need to set a property value as well SettableBeanProperty idProp = _objectIdReader.idProperty; if (idProp != null) { return idProp.setAndReturn(bean, _idValue); } } else { // TODO: is this an error case? throw ctxt.mappingException("No _idValue when handleIdValue called, on instance of " +bean.getClass().getName()); } } return bean; }
/** * Offlined method called to handle "native" Object Id that has been read * and known to be associated with given deserialized POJO. * * @since 2.3 */ protected Object _handleTypedObjectId(JsonParser p, DeserializationContext ctxt, Object pojo, Object rawId) throws IOException { // One more challenge: type of id may not be type of property we are expecting // later on; specifically, numeric ids vs Strings. JsonDeserializer<Object> idDeser = _objectIdReader.getDeserializer(); final Object id; // Ok, this is bit ridiculous; let's see if conversion is needed: if (idDeser.handledType() == rawId.getClass()) { // nope: already same type id = rawId; } else { id = _convertObjectId(p, ctxt, rawId, idDeser); } ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver); roid.bindItem(pojo); // also: may need to set a property value as well SettableBeanProperty idProp = _objectIdReader.idProperty; if (idProp != null) { return idProp.setAndReturn(pojo, id); } return pojo; }
private void handleUnresolvedReference(JsonParser jp, MapReferringAccumulator accumulator, Object key, UnresolvedForwardReference reference) throws JsonMappingException { if (accumulator == null) { throw JsonMappingException.from(jp, "Unresolved forward reference but no identity info.", reference); } Referring referring = accumulator.handleUnresolvedReference(reference, key); reference.getRoid().appendReferring(referring); }
/** * Helper method called to handle Object Id value collected earlier, if any */ public Object handleIdValue(final DeserializationContext ctxt, Object bean) throws IOException { if (_objectIdReader != null) { if (_idValue != null) { ReadableObjectId roid = ctxt.findObjectId(_idValue, _objectIdReader.generator, _objectIdReader.resolver); roid.bindItem(bean); // also: may need to set a property value as well SettableBeanProperty idProp = _objectIdReader.idProperty; if (idProp != null) { return idProp.setAndReturn(bean, _idValue); } } else { // 07-Jun-2016, tatu: Trying to improve error messaging here... ctxt.reportUnresolvedObjectId(_objectIdReader, bean); } } return bean; }
private void handleUnresolvedReference(DeserializationContext ctxt, MapReferringAccumulator accumulator, Object key, UnresolvedForwardReference reference) throws JsonMappingException { if (accumulator == null) { ctxt.reportInputMismatch(this, "Unresolved forward reference but no identity info: "+reference); } Referring referring = accumulator.handleUnresolvedReference(reference, key); reference.getRoid().appendReferring(referring); }
/** * @since 2.8 */ private BeanReferring handleUnresolvedReference(DeserializationContext ctxt, SettableBeanProperty prop, PropertyValueBuffer buffer, UnresolvedForwardReference reference) throws JsonMappingException { BeanReferring referring = new BeanReferring(ctxt, reference, prop.getType(), buffer, prop); reference.getRoid().appendReferring(referring); return referring; }
/** * Helper method called to handle Object Id value collected earlier, if any */ public Object handleIdValue(final DeserializationContext ctxt, Object bean) throws IOException { if (_objectIdReader != null) { if (_idValue != null) { ReadableObjectId roid = ctxt.findObjectId(_idValue, _objectIdReader.generator); roid.bindItem(bean); // also: may need to set a property value as well SettableBeanProperty idProp = _objectIdReader.idProperty; if (idProp != null) { return idProp.setAndReturn(bean, _idValue); } } else { // TODO: is this an error case? } } return bean; }
ReadableObjectId entry = new ReadableObjectId(key); entry.setResolver(resolver); _objectIds.put(key, entry); return entry;
public Object getUnresolvedId() { return _roid.getKey().key; }
entry.setResolver(resolver); _objectIds.put(key, entry); return entry;
/** * Overridable helper method called to try to resolve otherwise unresolvable {@link ReadableObjectId}; * and if this succeeds, return <code>true</code> to indicate problem has been resolved in * some way, so that caller can avoid reporting it as an error. *<p> * Default implementation simply calls {@link ReadableObjectId#tryToResolveUnresolved} and * returns whatever it returns. * * @since 2.6 */ protected boolean tryToResolveUnresolvedObjectId(ReadableObjectId roid) { return roid.tryToResolveUnresolved(this); }
/** * Method called to deserialize appropriate value, given parser (and * context), and set it using appropriate method (a setter method). */ public final void deserializeAndSet(JsonParser p, DeserializationContext ctxt, Object instance, String propName) throws IOException { try { Object key = (_keyDeserializer == null) ? propName : _keyDeserializer.deserializeKey(propName, ctxt); set(instance, key, deserialize(p, ctxt)); } catch (UnresolvedForwardReference reference) { if (!(_valueDeserializer.getObjectIdReader() != null)) { throw JsonMappingException.from(p, "Unresolved forward reference but no identity info.", reference); } AnySetterReferring referring = new AnySetterReferring(this, reference, _type.getRawClass(), instance, propName); reference.getRoid().appendReferring(referring); } }