/** * Similar to {@link #isExpectedStartArrayToken()}, but checks whether stream * currently points to {@link JsonToken#START_OBJECT}. * * @since 2.5 */ public boolean isExpectedStartObjectToken() { return currentToken() == JsonToken.START_OBJECT; }
@Override public JsonToken currentToken() { return delegate.currentToken(); } @Override public int currentTokenId() { return delegate.currentTokenId(); }
/** * Specialized accessor that can be used to verify that the current * token indicates start array (usually meaning that current token * is {@link JsonToken#START_ARRAY}) when start array is expected. * For some specialized parsers this can return true for other cases * as well; this is usually done to emulate arrays in cases underlying * format is ambiguous (XML, for example, has no format-level difference * between Objects and Arrays; it just has elements). *<p> * Default implementation is equivalent to: *<pre> * currentToken() == JsonToken.START_ARRAY *</pre> * but may be overridden by custom parser implementations. * * @return True if the current token can be considered as a * start-array marker (such {@link JsonToken#START_ARRAY}); * false if not. */ public boolean isExpectedStartArrayToken() { return currentToken() == JsonToken.START_ARRAY; }
/** * Similar to {@link #isExpectedStartArrayToken()}, but checks whether stream * currently points to {@link JsonToken#START_OBJECT}. */ public boolean isExpectedStartObjectToken() { return currentToken() == JsonToken.START_OBJECT; }
/** * @deprecated Since 3.0 use {@link #currentToken} instead. */ @Deprecated public JsonToken getCurrentToken() { return currentToken(); }
@Override public JsonToken nextToken() throws IOException { if (delegate == null) { return null; } if (_hasToken) { _hasToken = false; return delegate.currentToken(); } JsonToken t = delegate.nextToken(); if (t == null) { return switchAndReturnNext(); } return t; }
@Override public DateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { switch (jsonParser.currentToken()) { case VALUE_EMBEDDED_OBJECT: final Object embeddedObject = jsonParser.getEmbeddedObject(); if (embeddedObject instanceof Date) { final Date date = (Date) embeddedObject; return new DateTime(date, DateTimeZone.UTC); } else { throw new IllegalStateException("Unsupported token: " + jsonParser.currentToken()); } case VALUE_STRING: final String text = jsonParser.getText(); return DateTime.parse(text, FORMATTER).withZone(DateTimeZone.UTC); default: throw new IllegalStateException("Unsupported token: " + jsonParser.currentToken()); } } }
@Override public ZonedDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { switch (jsonParser.currentToken()) { case VALUE_EMBEDDED_OBJECT: final Object embeddedObject = jsonParser.getEmbeddedObject(); if (embeddedObject instanceof Date) { final Date date = (Date) embeddedObject; return ZonedDateTime.ofInstant(date.toInstant(), ZoneOffset.UTC); } else { throw new IllegalStateException("Unsupported token: " + jsonParser.currentToken()); } case VALUE_STRING: final String text = jsonParser.getText(); return ZonedDateTime.parse(text, FORMATTER).withZoneSameInstant(ZoneOffset.UTC); default: throw new IllegalStateException("Unsupported token: " + jsonParser.currentToken()); } } }
protected JsonToken switchAndReturnNext() throws IOException { while (_nextParserIndex < _parsers.length) { delegate = _parsers[_nextParserIndex++]; if (_checkForExistingToken && delegate.hasCurrentToken()) { return delegate.currentToken(); } JsonToken t = delegate.nextToken(); if (t != null) { return t; } } return null; } }
/** * Convenience accessor that can be called when the current * token is {@link JsonToken#VALUE_TRUE} or * {@link JsonToken#VALUE_FALSE}. *<p> * Note: if the token is not of above-mentioned boolean types, an integer, but its value falls * outside of range of Java long, a {@link JsonParseException} * may be thrown to indicate numeric overflow/underflow. */ public boolean getBooleanValue() throws IOException { JsonToken t = currentToken(); if (t == JsonToken.VALUE_TRUE) return true; if (t == JsonToken.VALUE_FALSE) return false; throw new JsonParseException(this, String.format("Current token (%s) not of boolean type", t)) .withRequestPayload(_requestPayload); }
@SuppressWarnings("unchecked") protected <R> R _handleUnexpectedToken(DeserializationContext context, JsonParser parser, JsonToken... expTypes) throws JsonMappingException { return _handleUnexpectedToken(context, parser, "Unexpected token (%s), expected one of %s for %s value", parser.currentToken(), Arrays.asList(expTypes), handledType().getName()); }
/** * Need to override, re-implement similar to how method defined in * {@link com.fasterxml.jackson.core.base.ParserMinimalBase}, to keep * state correct here. */ @Override public JsonParser skipChildren() throws IOException { if ((delegate.currentToken() != JsonToken.START_OBJECT) && (delegate.currentToken() != JsonToken.START_ARRAY)) { return this; } int open = 1; // Since proper matching of start/end markers is handled // by nextToken(), we'll just count nesting levels here while (true) { JsonToken t = nextToken(); if (t == null) { // not ideal but for now, just return return this; } if (t.isStructStart()) { ++open; } else if (t.isStructEnd()) { if (--open == 0) { return this; } } } }
public static Long currentTokenAsReal(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return VarcharOperators.castToFloat(Slices.utf8Slice(parser.getText())); case VALUE_NUMBER_FLOAT: return (long) floatToRawIntBits(parser.getFloatValue()); case VALUE_NUMBER_INT: // An alternative is calling getLongValue and then BigintOperators.castToReal. // It doesn't work as well because it can result in overflow and underflow exceptions for large integral numbers. return (long) floatToRawIntBits(parser.getFloatValue()); case VALUE_TRUE: return BooleanOperators.castToReal(true); case VALUE_FALSE: return BooleanOperators.castToReal(false); default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.REAL, parser.getText())); } }
public static Slice currentTokenAsVarchar(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return Slices.utf8Slice(parser.getText()); case VALUE_NUMBER_FLOAT: // Avoidance of loss of precision does not seem to be possible here because of Jackson implementation. return DoubleOperators.castToVarchar(parser.getDoubleValue()); case VALUE_NUMBER_INT: // An alternative is calling getLongValue and then BigintOperators.castToVarchar. // It doesn't work as well because it can result in overflow and underflow exceptions for large integral numbers. return Slices.utf8Slice(parser.getText()); case VALUE_TRUE: return BooleanOperators.castToVarchar(true); case VALUE_FALSE: return BooleanOperators.castToVarchar(false); default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.VARCHAR, parser.getText())); } }
public static Long currentTokenAsInteger(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return VarcharOperators.castToInteger(Slices.utf8Slice(parser.getText())); case VALUE_NUMBER_FLOAT: return DoubleOperators.castToInteger(parser.getDoubleValue()); case VALUE_NUMBER_INT: return (long) toIntExact(parser.getLongValue()); case VALUE_TRUE: return BooleanOperators.castToInteger(true); case VALUE_FALSE: return BooleanOperators.castToInteger(false); default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.INTEGER, parser.getText())); } }
public static Boolean currentTokenAsBoolean(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return VarcharOperators.castToBoolean(Slices.utf8Slice(parser.getText())); case VALUE_NUMBER_FLOAT: return DoubleOperators.castToBoolean(parser.getDoubleValue()); case VALUE_NUMBER_INT: return BigintOperators.castToBoolean(parser.getLongValue()); case VALUE_TRUE: return true; case VALUE_FALSE: return false; default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.BOOLEAN, parser.getText())); } }
public static Double currentTokenAsDouble(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return VarcharOperators.castToDouble(Slices.utf8Slice(parser.getText())); case VALUE_NUMBER_FLOAT: return parser.getDoubleValue(); case VALUE_NUMBER_INT: // An alternative is calling getLongValue and then BigintOperators.castToDouble. // It doesn't work as well because it can result in overflow and underflow exceptions for large integral numbers. return parser.getDoubleValue(); case VALUE_TRUE: return BooleanOperators.castToDouble(true); case VALUE_FALSE: return BooleanOperators.castToDouble(false); default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.DOUBLE, parser.getText())); } }
public static Long currentTokenAsBigint(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return VarcharOperators.castToBigint(Slices.utf8Slice(parser.getText())); case VALUE_NUMBER_FLOAT: return DoubleOperators.castToLong(parser.getDoubleValue()); case VALUE_NUMBER_INT: return parser.getLongValue(); case VALUE_TRUE: return BooleanOperators.castToBigint(true); case VALUE_FALSE: return BooleanOperators.castToBigint(false); default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.BIGINT, parser.getText())); } }
public static Long currentTokenAsSmallint(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return VarcharOperators.castToSmallint(Slices.utf8Slice(parser.getText())); case VALUE_NUMBER_FLOAT: return DoubleOperators.castToSmallint(parser.getDoubleValue()); case VALUE_NUMBER_INT: return (long) Shorts.checkedCast(parser.getLongValue()); case VALUE_TRUE: return BooleanOperators.castToSmallint(true); case VALUE_FALSE: return BooleanOperators.castToSmallint(false); default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.SMALLINT, parser.getText())); } }
public static Long currentTokenAsTinyint(JsonParser parser) throws IOException { switch (parser.currentToken()) { case VALUE_NULL: return null; case VALUE_STRING: case FIELD_NAME: return VarcharOperators.castToTinyint(Slices.utf8Slice(parser.getText())); case VALUE_NUMBER_FLOAT: return DoubleOperators.castToTinyint(parser.getDoubleValue()); case VALUE_NUMBER_INT: return (long) SignedBytes.checkedCast(parser.getLongValue()); case VALUE_TRUE: return BooleanOperators.castToTinyint(true); case VALUE_FALSE: return BooleanOperators.castToTinyint(false); default: throw new JsonCastException(format("Unexpected token when cast to %s: %s", StandardTypes.TINYINT, parser.getText())); } }