private UUID _badFormat(String uuidStr, DeserializationContext ctxt) throws IOException { return (UUID) ctxt.handleWeirdStringValue(handledType(), uuidStr, "UUID has to be represented by standard 36-char representation"); }
/** * @since 2.9 */ protected final long _parseLongPrimitive(DeserializationContext ctxt, String text) throws IOException { try { return NumberInput.parseLong(text); } catch (IllegalArgumentException iae) { } { Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid long value"); return _nonNullNumber(v).longValue(); } }
protected final byte _parseBytePrimitive(JsonParser p, DeserializationContext ctxt) throws IOException { int value = _parseIntPrimitive(p, ctxt); // So far so good: but does it fit? if (_byteOverflow(value)) { Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, String.valueOf(value), "overflow, value cannot be represented as 8-bit value"); return _nonNullNumber(v).byteValue(); } return (byte) value; }
protected final short _parseShortPrimitive(JsonParser p, DeserializationContext ctxt) throws IOException { int value = _parseIntPrimitive(p, ctxt); // So far so good: but does it fit? if (_shortOverflow(value)) { Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, String.valueOf(value), "overflow, value cannot be represented as 16-bit value"); return _nonNullNumber(v).shortValue(); } return (short) value; }
/** * @since 2.9 */ protected final int _parseIntPrimitive(DeserializationContext ctxt, String text) throws IOException { try { if (text.length() > 9) { long l = Long.parseLong(text); if (_intOverflow(l)) { Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text, "Overflow: numeric value (%s) out of range of int (%d -%d)", text, Integer.MIN_VALUE, Integer.MAX_VALUE); return _nonNullNumber(v).intValue(); } return (int) l; } return NumberInput.parseInt(text); } catch (IllegalArgumentException iae) { Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid int value"); return _nonNullNumber(v).intValue(); } }
@Override protected java.util.Date _parseDate(JsonParser p, DeserializationContext ctxt) throws IOException { if (_customFormat != null) { if (p.hasToken(JsonToken.VALUE_STRING)) { String str = p.getText().trim(); if (str.length() == 0) { return (Date) getEmptyValue(ctxt); } synchronized (_customFormat) { try { return _customFormat.parse(str); } catch (ParseException e) { return (java.util.Date) ctxt.handleWeirdStringValue(handledType(), str, "expected format \"%s\"", _formatString); } } } } return super._parseDate(p, ctxt); } }
/** * @since 2.9 */ protected final float _parseFloatPrimitive(DeserializationContext ctxt, String text) throws IOException { switch (text.charAt(0)) { case 'I': if (_isPosInf(text)) { return Float.POSITIVE_INFINITY; } break; case 'N': if (_isNaN(text)) { return Float.NaN; } break; case '-': if (_isNegInf(text)) { return Float.NEGATIVE_INFINITY; } break; } try { return Float.parseFloat(text); } catch (IllegalArgumentException iae) { } Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid float value"); return _nonNullNumber(v).floatValue(); }
return false; Boolean b = (Boolean) ctxt.handleWeirdStringValue(_valueClass, text, "only \"true\" or \"false\" recognized"); return Boolean.TRUE.equals(b);
@SuppressWarnings("unchecked") protected <R> R _handleDateTimeException(DeserializationContext context, DateTimeException e0, String value) throws JsonMappingException { try { return (R) context.handleWeirdStringValue(handledType(), value, "Failed to deserialize %s: (%s) %s", handledType().getName(), e0.getClass().getName(), e0.getMessage()); } catch (JsonMappingException e) { e.initCause(e0); throw e; } catch (IOException e) { if (null == e.getCause()) { e.initCause(e0); } throw JsonMappingException.fromUnexpectedIOE(e); } }
/** * @since 2.9 */ protected final double _parseDoublePrimitive(DeserializationContext ctxt, String text) throws IOException { switch (text.charAt(0)) { case 'I': if (_isPosInf(text)) { return Double.POSITIVE_INFINITY; } break; case 'N': if (_isNaN(text)) { return Double.NaN; } break; case '-': if (_isNegInf(text)) { return Double.NEGATIVE_INFINITY; } break; } try { return parseDouble(text); } catch (IllegalArgumentException iae) { } Number v = (Number) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid double value (as String to convert)"); return _nonNullNumber(v).doubleValue(); }
return (Boolean) _coerceTextualNull(ctxt, _primitive); return (Boolean) ctxt.handleWeirdStringValue(_valueClass, text, "only \"true\" or \"false\" recognized");
/** * @since 2.8 */ protected java.util.Date _parseDate(String value, DeserializationContext ctxt) throws IOException { try { // Take empty Strings to mean 'empty' Value, usually 'null': if (_isEmptyOrTextualNull(value)) { return (java.util.Date) getNullValue(ctxt); } return ctxt.parseDate(value); } catch (IllegalArgumentException iae) { return (java.util.Date) ctxt.handleWeirdStringValue(_valueClass, value, "not a valid representation (error: %s)", ClassUtil.exceptionMessage(iae)); } }
int index = Integer.parseInt(name); if (!ctxt.isEnabled(MapperFeature.ALLOW_COERCION_OF_SCALARS)) { return ctxt.handleWeirdStringValue(_enumClass(), name, "value looks like quoted Enum index, but `MapperFeature.ALLOW_COERCION_OF_SCALARS` prevents use" ); return ctxt.handleWeirdStringValue(_enumClass(), name, "value not one of declared Enum instance names: %s", lookup.keys());
long l = Long.parseLong(text); if (_intOverflow(l)) { return (Integer) ctxt.handleWeirdStringValue(_valueClass, text, String.format( "Overflow: numeric value (%s) out of range of Integer (%d - %d)", text, Integer.MIN_VALUE, Integer.MAX_VALUE)); return (Integer) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid Integer value");
@Override public BigDecimal deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { switch (p.getCurrentTokenId()) { case JsonTokenId.ID_NUMBER_INT: case JsonTokenId.ID_NUMBER_FLOAT: return p.getDecimalValue(); case JsonTokenId.ID_STRING: String text = p.getText().trim(); // note: no need to call `coerce` as this is never primitive if (_isEmptyOrTextualNull(text)) { _verifyNullForScalarCoercion(ctxt, text); return getNullValue(ctxt); } _verifyStringForScalarCoercion(ctxt, text); try { return new BigDecimal(text); } catch (IllegalArgumentException iae) { } return (BigDecimal) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid representation"); case JsonTokenId.ID_START_ARRAY: return _deserializeFromArray(p, ctxt); } // Otherwise, no can do: return (BigDecimal) ctxt.handleUnexpectedToken(_valueClass, p); } }
value = NumberInput.parseInt(text); } catch (IllegalArgumentException iae) { return (Short) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid Short value"); return (Short) ctxt.handleWeirdStringValue(_valueClass, text, "overflow, value cannot be represented as 16-bit value");
value = NumberInput.parseInt(text); } catch (IllegalArgumentException iae) { return (Byte) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid Byte value"); return (Byte) ctxt.handleWeirdStringValue(_valueClass, text, "overflow, value cannot be represented as 8-bit value");
return parseDouble(text); } catch (IllegalArgumentException iae) { } return (Double) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid Double value");
return new BigInteger(text); } catch (IllegalArgumentException iae) { } return (BigInteger) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid representation");
return Long.valueOf(NumberInput.parseLong(text)); } catch (IllegalArgumentException iae) { } return (Long) ctxt.handleWeirdStringValue(_valueClass, text, "not a valid Long value");