/** * Method that deserializers should call if the first token of the value to * deserialize is of unexpected type (that is, type of token that deserializer * cannot handle). This could occur, for example, if a Number deserializer * encounter {@link JsonToken#START_ARRAY} instead of * {@link JsonToken#VALUE_NUMBER_INT} or {@link JsonToken#VALUE_NUMBER_FLOAT}. * * @param instClass Type that was to be instantiated * @param p Parser that points to the JSON value to decode * * @return Object that should be constructed, if any; has to be of type <code>instClass</code> * * @since 2.8 */ public Object handleUnexpectedToken(Class<?> instClass, JsonParser p) throws IOException { return handleUnexpectedToken(instClass, p.getCurrentToken(), p, null); }
/** * Helper method used for accessing String value, if possible, doing * necessary conversion or throwing exception as necessary. * * @since 2.1 */ protected final String _parseString(JsonParser p, DeserializationContext ctxt) throws IOException { JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_STRING) { return p.getText(); } // 07-Nov-2016, tatu: Caller should take care of unwrapping and there shouldn't // be need for extra pass here... /* // [databind#381] if ((t == JsonToken.START_ARRAY) && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) { p.nextToken(); final String parsed = _parseString(p, ctxt); _verifyEndArrayForSingle(p, ctxt); return parsed; } */ String value = p.getValueAsString(); if (value != null) { return value; } return (String) ctxt.handleUnexpectedToken(String.class, p); }
/** * Helper method that may be used to support fallback for Empty String / Empty Array * non-standard representations; usually for things serialized as JSON Objects. * * @since 2.5 */ @SuppressWarnings("unchecked") protected T _deserializeFromEmpty(JsonParser p, DeserializationContext ctxt) throws IOException { JsonToken t = p.getCurrentToken(); if (t == JsonToken.START_ARRAY) { if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT)) { t = p.nextToken(); if (t == JsonToken.END_ARRAY) { return null; } return (T) ctxt.handleUnexpectedToken(handledType(), p); } } else if (t == JsonToken.VALUE_STRING) { if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) { String str = p.getText().trim(); if (str.isEmpty()) { return null; } } } return (T) ctxt.handleUnexpectedToken(handledType(), p); }
@Override public LatencyContainer deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException { JsonToken currentToken = jp.getCurrentToken(); if (currentToken == JsonToken.VALUE_NUMBER_INT) { return LatencyContainer.latency(jp.getLongValue()); } if (currentToken == JsonToken.START_OBJECT) { jp.nextToken(); InternalLatencyContainer container = jp.readValueAs(InternalLatencyContainer.class); return container.toLatencyContainer(); } return (LatencyContainer) ctxt.handleUnexpectedToken(LatencyContainer.class, jp); }
JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_STRING) { while ((t = p.nextToken()) != JsonToken.END_ARRAY) { String str; if (t == JsonToken.VALUE_STRING) { str = p.getText(); } else if (t == JsonToken.VALUE_NULL) { if (_nuller != null) { str = "\0"; } else { CharSequence cs = (CharSequence) ctxt.handleUnexpectedToken(Character.TYPE, p); str = cs.toString(); return (char[]) ctxt.handleUnexpectedToken(_valueClass, p);
@SuppressWarnings("unchecked") protected T handleNonArray(JsonParser p, DeserializationContext ctxt) throws IOException { // Empty String can become null... if (p.hasToken(JsonToken.VALUE_STRING) && ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) { if (p.getText().length() == 0) { return null; } } boolean canWrap = (_unwrapSingle == Boolean.TRUE) || ((_unwrapSingle == null) && ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)); if (canWrap) { return handleSingleElementUnwrapped(p, ctxt); } return (T) ctxt.handleUnexpectedToken(_valueClass, p); }
case JsonTokenId.ID_STRING: // this is the usual type String text = p.getText(); if (text.length() == 1) { return Character.valueOf(text.charAt(0)); default: return (Character) ctxt.handleUnexpectedToken(_valueClass, p);
if (ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) { JsonToken t = p.nextToken(); if (t == JsonToken.END_ARRAY && ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT)) { return null; if (p.nextToken() != JsonToken.END_ARRAY) { handleMissingEndArrayForSingle(p, ctxt); if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT)) { JsonToken t = p.nextToken(); if (t == JsonToken.END_ARRAY) { return null; return ctxt.handleUnexpectedToken(handledType(), JsonToken.START_ARRAY, p, null); return ctxt.handleUnexpectedToken(handledType(), p);
@SuppressWarnings("unchecked") protected final EnumSet<?> _deserialize(JsonParser p, DeserializationContext ctxt, EnumSet result) throws IOException { JsonToken t; try { while ((t = p.nextToken()) != JsonToken.END_ARRAY) { /* What to do with nulls? Fail or ignore? Fail, for now * (note: would fail if we passed it to EnumDeserializer, too, * but in general nulls should never be passed to non-container * deserializers) */ if (t == JsonToken.VALUE_NULL) { return (EnumSet<?>) ctxt.handleUnexpectedToken(_enumClass, p); } Enum<?> value = _enumDeserializer.deserialize(p, ctxt); /* 24-Mar-2012, tatu: As per [JACKSON-810], may actually get nulls; * but EnumSets don't allow nulls so need to skip. */ if (value != null) { result.add(value); } } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, result, result.size()); } return result; }
@Override public HttpProtocolVersion deserialize(final JsonParser jp, final DeserializationContext ctx) throws IOException { try { return HttpProtocolVersion.versionOf(strip(jp.getText())); } catch (IllegalArgumentException e) { return (HttpProtocolVersion) ctx.handleUnexpectedToken(HttpProtocolVersion.class, jp); } } }
JsonToken t = p.nextToken(); if (_vanillaProcessing) { return finishBuild(ctxt, vanillaDeserialize(p, ctxt, t)); default: return ctxt.handleUnexpectedToken(handledType(), p);
ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)); if (!canWrap) { return (Collection<String>) ctxt.handleUnexpectedToken(_containerType.getRawClass(), p); JsonToken t = p.getCurrentToken();
@SuppressWarnings("unchecked") protected EnumSet<?> handleNonArray(JsonParser p, DeserializationContext ctxt, EnumSet result) throws IOException { boolean canWrap = (_unwrapSingle == Boolean.TRUE) || ((_unwrapSingle == null) && ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)); if (!canWrap) { return (EnumSet<?>) ctxt.handleUnexpectedToken(EnumSet.class, p); } // First: since `null`s not allowed, slightly simpler... if (p.hasToken(JsonToken.VALUE_NULL)) { return (EnumSet<?>) ctxt.handleUnexpectedToken(_enumClass, p); } try { Enum<?> value = _enumDeserializer.deserialize(p, ctxt); if (value != null) { result.add(value); } } catch (Exception e) { throw JsonMappingException.wrapWithPath(e, result, result.size()); } return result; } }
@Override public CookieContainer deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException { JsonToken currentToken = jp.getCurrentToken(); if (currentToken == JsonToken.VALUE_STRING) { return CookieContainer.newContainer(strip(jp.getText())); } if (currentToken == JsonToken.START_OBJECT) { jp.nextToken(); InternalCookieContainer container = jp.readValueAs(InternalCookieContainer.class); return container.toContainer(); } return (CookieContainer) ctxt.handleUnexpectedToken(CookieContainer.class, jp); }
@Override public MessageContent deserialize(final JsonParser jp, final DeserializationContext ctx) throws IOException { JsonToken currentToken = jp.getCurrentToken(); if (currentToken == JsonToken.VALUE_STRING) { return content(strip(jp.getText())); } if (currentToken == JsonToken.START_OBJECT) { InternalMessageContent content = jp.readValueAs(InternalMessageContent.class); return content.toContent(); } return (MessageContent) ctx.handleUnexpectedToken(MessageContent.class, jp); } }
@Override public TextContainer deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException { JsonToken currentToken = jp.getCurrentToken(); if (currentToken == JsonToken.VALUE_STRING) { return helper.text(jp); } if (currentToken == JsonToken.START_OBJECT) { jp.nextToken(); return helper.textContainer(jp, ctxt); } return (TextContainer) ctxt.handleUnexpectedToken(TextContainer.class, jp); } }
private final String[] handleNonArray(JsonParser p, DeserializationContext ctxt) throws IOException { // implicit arrays from single values? boolean canWrap = (_unwrapSingle == Boolean.TRUE) || ((_unwrapSingle == null) && ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)); if (canWrap) { String value = p.hasToken(JsonToken.VALUE_NULL) ? (String) _nullProvider.getNullValue(ctxt) : _parseString(p, ctxt); return new String[] { value }; } 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; } } return (String[]) ctxt.handleUnexpectedToken(_valueClass, p); } }
protected Object _deserializeFromNonArray(JsonParser p, DeserializationContext ctxt) throws IOException { return ctxt.handleUnexpectedToken(handledType(), p.getCurrentToken(), p, "Cannot deserialize a POJO (of type %s) from non-Array representation (token: %s): " +"type/property designed to be serialized as JSON Array", _beanType.getRawClass().getName(), p.getCurrentToken()); // in future, may allow use of "standard" POJO serialization as well; if so, do: //return _delegate.deserialize(p, ctxt); } }
protected java.util.Date _parseDate(JsonParser p, DeserializationContext ctxt) throws IOException { switch (p.getCurrentTokenId()) { case JsonTokenId.ID_STRING: return _parseDate(p.getText().trim(), ctxt); case JsonTokenId.ID_NUMBER_INT: { long ts; try { ts = p.getLongValue(); } catch (JsonParseException e) { Number v = (Number) ctxt.handleWeirdNumberValue(_valueClass, p.getNumberValue(), "not a valid 64-bit long for creating `java.util.Date`"); ts = v.longValue(); } return new java.util.Date(ts); } case JsonTokenId.ID_NULL: return (java.util.Date) getNullValue(ctxt); case JsonTokenId.ID_START_ARRAY: return _parseDateFromArray(p, ctxt); } return (java.util.Date) ctxt.handleUnexpectedToken(_valueClass, p); }
/** * Helper method called for rare case of pointing to {@link JsonToken#VALUE_NULL} * token. While this is most often an erroneous condition, there is one specific * case with XML handling where polymorphic type with no properties is exposed * as such, and should be handled same as empty Object. * * @since 2.7 */ protected Object deserializeFromNull(JsonParser p, DeserializationContext ctxt) throws IOException { // 17-Dec-2015, tatu: Highly specialized case, mainly to support polymorphic // "empty" POJOs deserialized from XML, where empty XML tag synthesizes a // `VALUE_NULL` token. if (p.requiresCustomCodec()) { // not only XML module, but mostly it... @SuppressWarnings("resource") TokenBuffer tb = new TokenBuffer(p, ctxt); tb.writeEndObject(); JsonParser p2 = tb.asParser(p); p2.nextToken(); // to point to END_OBJECT // note: don't have ObjectId to consider at this point, so: Object ob = _vanillaProcessing ? vanillaDeserialize(p2, ctxt, JsonToken.END_OBJECT) : deserializeFromObject(p2, ctxt); p2.close(); return ob; } return ctxt.handleUnexpectedToken(handledType(), p); }