/** * Helper method for constructing generic mapping exception for specified type * * @deprecated Since 2.8 use {@link #handleUnexpectedToken(Class, JsonParser)} instead */ @Deprecated public JsonMappingException mappingException(Class<?> targetClass) { return mappingException(targetClass, _parser.getCurrentToken()); }
/** * Convenience method that may be used by composite or container deserializers, * for reading one-off values contained (for sequences, it is more efficient * to actually fetch deserializer once for the whole collection). *<p> * NOTE: when deserializing values of properties contained in composite types, * rather use {@link #readPropertyValue(JsonParser, BeanProperty, Class)}; * this method does not allow use of contextual annotations. * * @since 2.4 */ public <T> T readValue(JsonParser p, Class<T> type) throws IOException { return readValue(p, getTypeFactory().constructType(type)); }
@Override public Version deserialize(final JsonParser p, final DeserializationContext ctxt) throws IOException { switch (p.getCurrentTokenId()) { case JsonTokenId.ID_STRING: final String str = p.getText().trim(); return Version.valueOf(str); case JsonTokenId.ID_NUMBER_INT: return Version.forIntegers(p.getIntValue()); } throw ctxt.wrongTokenException(p, JsonToken.VALUE_STRING, "expected String or Number"); } }
@Override public void resolve(DeserializationContext ctxt) throws JsonMappingException { _treeDeserializer = ctxt.findRootValueDeserializer(ctxt.constructType(JsonNode.class)); }
/** * Method for deserializers to call * when the token encountered was of type different than what <b>should</b> * be seen at that position, usually within a sequence of expected tokens. * Note that this method will throw a {@link JsonMappingException} and no * recovery is attempted (via {@link DeserializationProblemHandler}, as * problem is considered to be difficult to recover from, in general. * * @since 2.9 */ public void reportWrongTokenException(Class<?> targetType, JsonToken expToken, String msg, Object... msgArgs) throws JsonMappingException { msg = _format(msg, msgArgs); throw wrongTokenException(getParser(), targetType, expToken, msg); }
/** * @since 2.4 */ @SuppressWarnings("unchecked") public <T> T readValue(JsonParser p, JavaType type) throws IOException { JsonDeserializer<Object> deser = findRootValueDeserializer(type); if (deser == null) { reportBadDefinition(type, "Could not find JsonDeserializer for type "+type); } return (T) deser.deserialize(p, this); }
PropertyValueBuffer buffer = creator.startBuilding(jp, ctxt); TokenBuffer tokens = new TokenBuffer(jp.getCodec()); tokens.writeStartObject(); JsonToken t = jp.getCurrentToken(); for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) { String propName = jp.getCurrentName(); jp.nextToken(); // to point to value if (creatorProp != null) { Object value = creatorProp.deserialize(jp, ctxt); if (buffer.assignParameter(creatorProp.getPropertyIndex(), value)) { t = jp.nextToken(); // to move to following FIELD_NAME/END_OBJECT Object bean; jp.nextToken(); // to skip name tokens.copyCurrentStructure(jp); t = jp.nextToken(); tokens.writeEndObject(); if (bean.getClass() != _beanType.getRawClass()) { throw ctxt.mappingException("Can not create polymorphic instances with unwrapped values");
private T deserializeObject(JsonParser jsonParser, DeserializationContext ctxt, JsonNodeFactory nodeFactory) throws IOException { T enteries = build(); NottableString key = string(""); while (true) { JsonToken token = jsonParser.nextToken(); switch (token) { case FIELD_NAME: key = string(jsonParser.getText()); break; case START_ARRAY: enteries.withEntry(key, ctxt.readValue(jsonParser, NottableString[].class)); break; case END_OBJECT: return enteries; default: throw new RuntimeException("Unexpected token: \"" + token + "\" id: \"" + token.id() + "\" text: \"" + jsonParser.getText()); } } }
p.setCurrentValue(result); if (p.isExpectedStartObjectToken()) { keyStr = p.nextFieldName(); } else { JsonToken t = p.getCurrentToken(); return result; ctxt.reportWrongTokenException(this, JsonToken.FIELD_NAME, null); keyStr = p.getCurrentName(); JsonToken t = p.nextToken(); if (key == null) { if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) { return (EnumMap<?,?>) ctxt.handleWeirdStringValue(_enumClass, keyStr, "value not one of declared Enum instance names for %s", _containerType.getKeyType()); value = valueDes.deserialize(p, ctxt); } else { value = valueDes.deserializeWithType(p, ctxt, typeDeser);
@Override public DateTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JsonToken t = jp.getCurrentToken(); if (t == JsonToken.VALUE_NUMBER_INT) { return DateTimes.utc(jp.getLongValue()); } if (t == JsonToken.VALUE_STRING) { String str = jp.getText().trim(); if (str.length() == 0) { // [JACKSON-360] return null; } // make sure to preserve time zone information when parsing timestamps return DateTimes.ISO_DATE_OR_TIME_WITH_OFFSET.parse(str); } throw ctxt.mappingException(getValueClass()); } }
@Override public KeySegment deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { switch (p.getCurrentToken()) { case VALUE_TRUE: case VALUE_FALSE: case VALUE_NUMBER_INT: case VALUE_STRING: return p.readValueAs(SimpleKey.class); case START_OBJECT: return p.readValueAs(NumberRange.class); case START_ARRAY: TokenBuffer buf = new TokenBuffer(p); buf.copyCurrentStructure(p); try { return buf.asParser().readValueAs(NumericSet.class); } catch (IOException e) { return buf.asParser().readValueAs(KeySet.class); } default: throw ctxt.mappingException(KeySegment.class); } }
if (p.isExpectedStartObjectToken()) { keyName = p.nextFieldName(); } else if (p.hasToken(JsonToken.FIELD_NAME)) { keyName = p.getCurrentName(); } else { if (prop != null) { if (buffer.assignParameter(prop, prop.deserialize(p, ctxt))) { p.nextToken(); // from value to END_OBJECT or FIELD_NAME EnumMap<?,?> result; result = (EnumMap<?,?>)creator.build(ctxt, buffer); } catch (Exception e) { return wrapAndThrow(e, _containerType.getRawClass(), keyName); if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) { return (EnumMap<?,?>) ctxt.handleWeirdStringValue(_enumClass, keyName, "value not one of declared Enum instance names for %s", _containerType.getKeyType()); value = _valueDeserializer.deserialize(p, ctxt); } else { value = _valueDeserializer.deserializeWithType(p, ctxt, _valueTypeDeserializer); wrapAndThrow(e, _containerType.getRawClass(), keyName); return null;
@SuppressWarnings("resource") protected Object _deserializeTypedUsingDefaultImpl(JsonParser jp, DeserializationContext ctxt, TokenBuffer tb) throws IOException { // As per [JACKSON-614], may have default implementation to use JsonDeserializer<Object> deser = _findDefaultImplDeserializer(ctxt); if (deser != null) { if (tb != null) { tb.writeEndObject(); jp = tb.asParser(jp); // must move to point to the first token: jp.nextToken(); } return deser.deserialize(jp, ctxt); } // or, perhaps we just bumped into a "natural" value (boolean/int/double/String)? Object result = TypeDeserializer.deserializeIfNatural(jp, ctxt, _baseType); if (result != null) { return result; } // or, something for which "as-property" won't work, changed into "wrapper-array" type: if (jp.getCurrentToken() == JsonToken.START_ARRAY) { return super.deserializeTypedFromAny(jp, ctxt); } throw ctxt.wrongTokenException(jp, JsonToken.FIELD_NAME, "missing property '"+_typePropertyName+"' that is to contain type id (for class "+baseTypeName()+")"); }
@Override public NottableString deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException { if (jsonParser.getCurrentToken() == JsonToken.START_OBJECT) { Boolean not = null; String string = null; while (jsonParser.nextToken() != JsonToken.END_OBJECT) { String fieldName = jsonParser.getCurrentName(); if ("not".equals(fieldName)) { jsonParser.nextToken(); not = jsonParser.getBooleanValue(); } else if ("value".equals(fieldName)) { jsonParser.nextToken(); string = ctxt.readValue(jsonParser, String.class); } } if (StringUtils.isEmpty(string)) { return null; } return string(string, not); } else if (jsonParser.getCurrentToken() == JsonToken.VALUE_STRING || jsonParser.getCurrentToken() == JsonToken.FIELD_NAME) { return string(ctxt.readValue(jsonParser, String.class)); } return null; }
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; ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)); if (!canWrap) { JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_STRING return deserializeFromBase64(p, ctxt); return (Object[]) ctxt.handleUnexpectedToken(_containerType.getRawClass(), p); JsonToken t = p.getCurrentToken(); value = _elementDeserializer.deserialize(p, ctxt); } else { value = _elementDeserializer.deserializeWithType(p, ctxt, _elementTypeDeserializer);
if (p.isExpectedStartArrayToken()) { return super.deserializeTypedFromAny(p, ctxt); if (p.hasToken(JsonToken.VALUE_STRING)) { if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) { String str = p.getText().trim(); if (str.isEmpty()) { return null; deser = ctxt.findContextualValueDeserializer(t, _property); tb.writeEndObject(); p = tb.asParser(p); p.nextToken(); return deser.deserialize(p, ctxt);
JsonToken token = parser.nextToken(); if (token != JsonToken.START_ARRAY ) throw deserializationContext.mappingException("Invalid data point syntax."); parser.nextToken(); long timestamp = parser.getLongValue(); parser.nextToken(); token = parser.nextToken(); if (token != JsonToken.END_ARRAY) throw deserializationContext.mappingException("Invalid data point syntax."); token = parser.nextToken();
@Override public AbstractEntity deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { Preconditions.checkState(jp.getCurrentToken() == JsonToken.START_OBJECT); jp.nextToken(); for (JsonToken t = jp.getCurrentToken(); t == JsonToken.FIELD_NAME; t = jp.nextToken()) { String propName = jp.getCurrentName(); jp.nextToken(); SettableBeanProperty property = _beanProperties.find(propName); if (property != null) { Object value = property.deserialize(jp, ctxt); if (property.getName().equals("id") && value != null) { jp.nextToken(); AbstractEntity entity = generalDao.load(entityClass, (Long)value); ctxt.handleUnexpectedToken(entityClass, jp);
if (jp.getCurrentToken() != JsonToken.START_ARRAY) { return finishBuild(ctxt, _deserializeFromNonArray(jp, ctxt)); return finishBuild(ctxt, _deserializeNonVanilla(jp, ctxt)); Object builder = _valueInstantiator.createUsingDefault(ctxt); final SettableBeanProperty[] props = _orderedProperties; int i = 0; final int propCount = props.length; while (true) { if (jp.nextToken() == JsonToken.END_ARRAY) { return finishBuild(ctxt, builder); if (prop != null) { // normal case try { builder = prop.deserializeSetAndReturn(jp, ctxt, builder); } catch (Exception e) { wrapAndThrow(e, builder, prop.getName(), ctxt); jp.skipChildren(); throw ctxt.mappingException("Unexpected JSON values; expected at most "+propCount+" properties (in JSON Array)");
if (!p.isExpectedStartArrayToken()) { return _deserializeFromNonArray(p, ctxt); return _deserializeNonVanilla(p, ctxt); final Object bean = _valueInstantiator.createUsingDefault(ctxt); p.setCurrentValue(bean); final int propCount = props.length; while (true) { if (p.nextToken() == JsonToken.END_ARRAY) { return bean; if (prop != null) { // normal case try { prop.deserializeAndSet(p, ctxt, bean); } catch (Exception e) { wrapAndThrow(e, bean, prop.getName(), ctxt); if (!_ignoreAllUnknown && ctxt.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)) { ctxt.reportWrongTokenException(this, JsonToken.END_ARRAY, "Unexpected JSON values; expected at most %d properties (in JSON Array)", propCount);