/** Parsers an int32 value out of the input. */ static int parseInt32(JsonParser parser) throws IOException { JsonToken token = parser.currentToken(); if (token == JsonToken.VALUE_NUMBER_INT) { // Use optimized code path for integral primitives, the normal case. return parser.getIntValue(); } // JSON doesn't distinguish between integer values and floating point values so "1" and // "1.000" are treated as equal in JSON. For this reason we accept floating point values for // integer fields as well as long as it actually is an integer (i.e., round(value) == value). try { BigDecimal value = new BigDecimal( parser.getTextCharacters(), parser.getTextOffset(), parser.getTextLength()); return value.intValueExact(); } catch (Exception e) { throw new InvalidProtocolBufferException("Not an int32 value: " + parser.getText()); } }
/** * @param content * @throws JsonParseException * @throws IOException */ public PageInstance parse(String content) throws JsonParseException, IOException { JsonFactory f = new JsonFactory(); JsonParser parser = f.createJsonParser(content); JsonToken current = parser.nextToken(); // move to the start of the // object String instanceId = getNextTextValue("sid", parser); // get instanceId String pageId = getNextTextValue("cid", parser); // get pageId current = parser.nextToken(); // move to field: segments assertExpectedFiled(parser.getCurrentName(), "segments", parser.getCurrentLocation()); PageInstance pageInstance = new PageInstance(); pageInstance.setCid(pageId); pageInstance.setSid(Long.valueOf(instanceId)); pageInstance.setSegments(parseSegments(parser)); return pageInstance; // 构建组件树,用于递归渲染 // pageInstance.buildComponentTree(); }
/** * Unmarshalls the current token in the Json document to list. */ private List<T> unmarshallJsonToList(JsonUnmarshallerContext context) throws Exception { List<T> list = new ArrayList<T>(); if (context.getCurrentToken() == JsonToken.VALUE_NULL) { return null; } while (true) { JsonToken token = context.nextToken(); if (token == null) { return list; } if (token == END_ARRAY) { return list; } else { list.add(itemUnmarshaller.unmarshall(context)); } } }
@Test public void testGetCurrentNameNotAtFieldReturnsNull() throws IOException { IonParser parser = parse("{foo:\"abc\"} [a, b] {{}} \"bar\""); assertEquals(JsonToken.START_OBJECT, parser.nextToken()); assertNull(parser.getCurrentName()); assertEquals(JsonToken.VALUE_STRING, parser.nextValue()); assertEquals(JsonToken.END_OBJECT, parser.nextToken()); assertNull(parser.getCurrentName()); assertEquals(JsonToken.START_ARRAY, parser.nextToken()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertNull(parser.getCurrentName()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertNull(parser.getCurrentName()); assertEquals(JsonToken.END_ARRAY, parser.nextToken()); assertNull(parser.getCurrentName()); assertEquals(JsonToken.VALUE_EMBEDDED_OBJECT, parser.nextToken()); assertNull(parser.getCurrentName()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertNull(parser.getCurrentName()); assertNull(parser.nextToken()); assertNull(parser.getCurrentName()); }
@Nullable public static List<Object> readArray(JsonParser jp) throws IOException { if (jp.currentToken() != JsonToken.START_ARRAY) { return null; } List<Object> result = new ArrayList<>(); JsonToken token = jp.nextToken(); while (token != JsonToken.END_ARRAY) { if (token == JsonToken.START_ARRAY) { result.add(readArray(jp)); } else if (token == JsonToken.START_OBJECT) { result.add(readObject(jp)); } else { result.add(getValue(jp)); } token = jp.nextToken(); } return result; }
@Test public void test_parsePosNumber() throws IOException { byte[] byteArray = new byte[2]; byteArray[0] = (byte) 51; byteArray[1] = (byte) 22; IOContext ioContext = new IOContext(new BufferRecycler(), byteArray, false); InputStream byteArrayInputStream = new ByteArrayInputStream(byteArray); ByteQuadsCanonicalizer byteQuadsCanonicalizer = ByteQuadsCanonicalizer.createRoot(); DataInputStream dataInputStream = new DataInputStream(byteArrayInputStream); UTF8DataInputJsonParser uTF8DataInputJsonParser = new UTF8DataInputJsonParser(ObjectReadContext.empty(), ioContext, 1568, dataInputStream, byteQuadsCanonicalizer, 13); JsonToken jsonToken = uTF8DataInputJsonParser._parsePosNumber(7); assertEquals(7, jsonToken.id()); assertNull(jsonToken.asString()); }
public void testSurrogatesWithRaw() throws Exception { final String VALUE = quote("\ud83d\ude0c"); ByteArrayOutputStream out = new ByteArrayOutputStream(); JsonGenerator g = JSON_F.createGenerator(ObjectWriteContext.empty(), out); g.writeStartArray(); g.writeRaw(VALUE); g.writeEndArray(); g.close(); final byte[] JSON = out.toByteArray(); JsonParser jp = JSON_F.createParser(ObjectReadContext.empty(), JSON); assertToken(JsonToken.START_ARRAY, jp.nextToken()); assertToken(JsonToken.VALUE_STRING, jp.nextToken()); String str = jp.getText(); assertEquals(2, str.length()); assertEquals((char) 0xD83D, str.charAt(0)); assertEquals((char) 0xDE0C, str.charAt(1)); assertToken(JsonToken.END_ARRAY, jp.nextToken()); jp.close(); }
private void parseInputArrayOfStrings(final JsonParser parser, final List<String> inputs, final DriverCache cache, final Set<ValueGroup> groups) { EhSupport.propagate(() -> { parser.nextToken(); while (parser.nextToken() != JsonToken.END_ARRAY) { String value = parser.getText(); if (value.startsWith(GroupDriver.VG_PREFIX) && !cache.contains(value)) { final String groupName = value.split(":")[1]; final Optional<ValueGroup> group = groups.stream().filter(valueGroup -> valueGroup.getName().equals(groupName)).findFirst(); if (group.isPresent()) { value = GroupDriver.VG_PREFIX + group.get().getId(); } else { inputs.add(value); } } inputs.add(value); } }); }
public void testToDoubleCoercion() throws Exception { for (int mode : ALL_STREAMING_MODES) { JsonParser p; // BigDecimal->double p = createParser(mode, "100.5"); assertToken(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken()); assertEquals(new BigDecimal("100.5"), p.getDecimalValue()); assertEquals(100.5, p.getDoubleValue()); p.close(); p = createParser(mode, "10"); assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken()); assertEquals(BigInteger.TEN, p.getBigIntegerValue()); assertEquals(10.0, p.getDoubleValue()); p.close(); } }
@Test public void testNextValue() throws IOException { IonParser parser = parse("{foo:{bar:\"abc\"}, baz:123} 42.0"); assertEquals(JsonToken.START_OBJECT, parser.nextValue()); assertEquals(JsonToken.START_OBJECT, parser.nextValue()); assertEquals("foo", parser.getCurrentName()); assertEquals(JsonToken.VALUE_STRING, parser.nextValue()); assertEquals("abc", parser.getText()); assertEquals("bar", parser.getCurrentName()); assertEquals(JsonToken.END_OBJECT, parser.nextValue()); assertEquals(JsonToken.VALUE_NUMBER_INT, parser.nextValue()); assertEquals(123, parser.getIntValue()); assertEquals("baz", parser.getCurrentName()); assertEquals(JsonToken.END_OBJECT, parser.nextValue()); assertEquals(JsonToken.VALUE_NUMBER_FLOAT, parser.nextValue()); assertEquals(42.0, parser.getFloatValue(), 1e-9); assertNull(parser.nextValue()); }
@Override public void parse(IonParser parser) throws IOException { assertEquals(JsonToken.VALUE_NUMBER_INT, parser.nextToken()); assertEquals(BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE), parser.getBigIntegerValue()); try { parser.getLongValue(); } catch (IonException e1) { assertEquals(JsonToken.VALUE_NUMBER_INT, parser.nextToken()); assertEquals(BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE), parser.getBigIntegerValue()); try { parser.getLongValue(); } catch (IonException e2) { return; } } throw new AssertionError("number shouldn't fit in a long"); }
@Override public Object objectText() throws IOException { JsonToken currentToken = parser.getCurrentToken(); if (currentToken == JsonToken.VALUE_STRING) { return text(); } else if (currentToken == JsonToken.VALUE_NUMBER_INT || currentToken == JsonToken.VALUE_NUMBER_FLOAT) { return parser.getNumberValue(); } else if (currentToken == JsonToken.VALUE_TRUE) { return Boolean.TRUE; } else if (currentToken == JsonToken.VALUE_FALSE) { return Boolean.FALSE; } else if (currentToken == JsonToken.VALUE_NULL) { return null; } else { return text(); } }
public static <T> List<Extension<T>> readExtensions(JsonParser parser, DeserializationContext context) throws IOException { Objects.requireNonNull(parser); Objects.requireNonNull(context); List<Extension<T>> extensions = new ArrayList<>(); while (parser.nextToken() != JsonToken.END_OBJECT) { String extensionName = parser.getCurrentName(); ExtensionJson extensionJson = ExtensionSupplier.findExtensionJson(extensionName); if (extensionJson != null) { parser.nextToken(); Extension<T> extension = extensionJson.deserialize(parser, context); extensions.add(extension); } else { skip(parser); } } return extensions; }
@Override public ParentModel parse(JsonParser jsonParser) throws IOException { ParentModel instance = new ParentModel(); if (jsonParser.getCurrentToken() == null) { jsonParser.nextToken(); } if (jsonParser.getCurrentToken() != JsonToken.START_OBJECT) { jsonParser.skipChildren(); return null; } while (jsonParser.nextToken() != JsonToken.END_OBJECT) { String fieldName = jsonParser.getCurrentName(); jsonParser.nextToken(); parseField(instance, fieldName, jsonParser); jsonParser.skipChildren(); } return instance; }
/** * Read events mock file, and push it * * @param dataProducer contains the queue * @param mapper indicates how to parse the file * @param parser contains mocks * @param start time when method is called * @return true if interrupted, False if it ended with normal behaviour * @see IDataProducer */ default boolean readMockFile(IDataProducer dataProducer, ObjectMapper mapper, JsonParser parser, long start) { try { while (parser.nextToken() == JsonToken.START_OBJECT) { ObjectNode objectNode = mapper.readTree(parser); Event event = getEventFromJson(objectNode); pushIfValidEvent(dataProducer, event, start); } } catch (IOException e) { LOGGER.error("Something went wrong with the facebook post reading"); return true; } finally { Thread.currentThread().interrupt(); } return false; }
public static YieldMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); ParserUtil.readObject(jp); List<Object> arguments = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_ARRAY) { arguments = ParserUtil.readArray(jp); } Map<String, Object> argumentsKw = null; token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { argumentsKw = ParserUtil.readObject(jp); } return new YieldMessage(request, arguments, argumentsKw); }
@Override public PrePostProcessingModel parse(JsonParser jsonParser) throws IOException { PrePostProcessingModel instance = new PrePostProcessingModel(); if (jsonParser.getCurrentToken() == null) { jsonParser.nextToken(); } if (jsonParser.getCurrentToken() != JsonToken.START_OBJECT) { jsonParser.skipChildren(); return null; } while (jsonParser.nextToken() != JsonToken.END_OBJECT) { String fieldName = jsonParser.getCurrentName(); jsonParser.nextToken(); parseField(instance, fieldName, jsonParser); jsonParser.skipChildren(); } instance.onParseComplete(); return instance; }
@Test public void testNestedSexp() throws IOException { IonParser parser = parse("((a)+(b))"); assertEquals(JsonToken.START_ARRAY, parser.nextToken()); assertEquals(JsonToken.START_ARRAY, parser.nextToken()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("a", parser.getText()); assertEquals(JsonToken.END_ARRAY, parser.nextToken()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("+", parser.getText()); assertEquals(JsonToken.START_ARRAY, parser.nextToken()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("b", parser.getText()); assertEquals(JsonToken.END_ARRAY, parser.nextToken()); assertEquals(JsonToken.END_ARRAY, parser.nextToken()); assertNull(parser.nextToken()); }
public static ErrorMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); int type = jp.getIntValue(); jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); ParserUtil.readObject(jp); jp.nextToken(); String error = jp.getValueAsString(); List<Object> arguments = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_ARRAY) { arguments = ParserUtil.readArray(jp); } Map<String, Object> argumentsKw = null; token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { argumentsKw = ParserUtil.readObject(jp); } return new ErrorMessage(type, request, error, arguments, argumentsKw); }
void mergeValue(JsonParser parser, int currentDepth, Message.Builder builder) throws IOException { ParseSupport.checkRecursionLimit(currentDepth); JsonToken json = parser.currentToken(); if (json == null) { // Nested messages will already have current token set, but top-level ones will not. json = parser.nextToken(); } if (json != JsonToken.START_OBJECT) { throw new InvalidProtocolBufferException( "Expected start of object, got: " + parser.getText()); } doMerge(parser, currentDepth, builder); // Object end will be handled in ParseSupport.checkObjectEnd. }
public static String getNextTextValue(String fieldName, JsonParser parser) throws JsonParseException, IOException { JsonToken current = parser.nextToken(); // move to filed if (current != JsonToken.FIELD_NAME || !fieldName.equals(parser.getCurrentName())) { reportParseError("Error occoured while getting value by field name:" + fieldName, parser.getCurrentLocation()); } current = parser.nextToken(); // move to value return parser.getText(); }
@Override public void parse(IonParser parser) throws IOException { assertEquals(JsonToken.START_ARRAY, parser.nextToken()); assertEquals(JsonToken.VALUE_NUMBER_INT, parser.nextToken()); assertEquals(42, parser.getIntValue()); assertEquals(JsonToken.START_OBJECT, parser.nextToken()); parser.skipChildren(); assertEquals(JsonToken.END_OBJECT, parser.getCurrentToken()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("foo", parser.getText()); assertEquals(JsonToken.END_ARRAY, parser.nextToken()); }
@Override public void parse(IonParser parser) throws IOException { assertEquals(JsonToken.VALUE_NUMBER_INT, parser.nextToken()); assertEquals(42, parser.getIntValue()); assertEquals(JsonToken.START_OBJECT, parser.nextToken()); parser.skipChildren(); assertEquals(JsonToken.END_OBJECT, parser.getCurrentToken()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("foo", parser.getText()); }
/** Parses a long out of the input, using the optimized path when the value is not quoted. */ private static long parseLong(JsonParser parser) throws IOException { if (parser.currentToken() == JsonToken.VALUE_NUMBER_INT) { return parser.getLongValue(); } return NumberInput.parseLong(parser.getText()); }
private Department parseDepartment() throws Exception { accept(JsonToken.START_OBJECT); Department company = new Department(); for (;;) { JsonToken tok = parser.getCurrentToken(); if (tok == JsonToken.END_OBJECT) { break; } if (tok == JsonToken.FIELD_NAME) { String name = parser.getCurrentName(); tok = parser.nextToken(); if ("name" == name) { company.setName(acceptString(tok)); } else if ("description" == name) { company.setDescription(acceptString(tok)); } else if ("id" == name) { company.setId(acceptLong(tok)); } else if ("children" == name) { parseDepartment(company.getChildren()); } else if ("members" == name) { parseEmployee(company.getMembers()); } else { throw new RuntimeException("not match property : " + name); } } } accept(JsonToken.END_OBJECT); return company; }
@Override public void parse(IonParser parser) throws IOException { assertEquals(JsonToken.VALUE_NUMBER_FLOAT, parser.nextToken()); assertEquals(BigDecimal.valueOf(Double.MAX_VALUE).add(BigDecimal.ONE), parser.getDecimalValue()); assertEquals(JsonToken.VALUE_NUMBER_FLOAT, parser.nextToken()); assertEquals(BigDecimal.valueOf(-Double.MAX_VALUE).subtract(BigDecimal.ONE), parser.getDecimalValue()); }
public static InvocationMessage deserialize(JsonParser jp) throws IOException { jp.nextToken(); long request = jp.getLongValue(); jp.nextToken(); long registration = jp.getLongValue(); jp.nextToken(); Number caller = null; Map<String, Object> details = ParserUtil.readObject(jp); if (details != null) { caller = (Number) details.get("caller"); } List<Object> arguments = null; JsonToken token = jp.nextToken(); if (token == JsonToken.START_ARRAY) { arguments = ParserUtil.readArray(jp); } Map<String, Object> argumentsKw = null; token = jp.nextToken(); if (token == JsonToken.START_OBJECT) { argumentsKw = ParserUtil.readObject(jp); } return new InvocationMessage(request, registration, caller, arguments, argumentsKw); }
@Override public JsonToken peek() throws IOException { if (nextToken != null) { return nextToken; } nextToken = jsonParser.nextToken(); return nextToken; }
private boolean acceptBoolean(JsonToken token) throws Exception { if (token == JsonToken.VALUE_TRUE) { parser.nextToken(); return true; } else if (token == JsonToken.VALUE_FALSE) { parser.nextToken(); return false; } else { throw new JSONException("syntax error, expect string, actual " + parser.getCurrentToken()); } }
private BigDecimal acceptBigDecimal(JsonToken token) throws Exception { if (token == JsonToken.VALUE_NUMBER_FLOAT) { BigDecimal value = parser.getDecimalValue(); parser.nextToken(); return value; } else { throw new JSONException("syntax error, expect string, actual " + parser.getCurrentToken()); } }
@Test public void testDeserializeNumber() throws IOException { JsonParser parser = mock(JsonParser.class); when(parser.hasToken(eq(JsonToken.VALUE_NUMBER_INT))).thenReturn(true); when(parser.getLongValue()).thenReturn(1480520820000L); TimestampDeserializer deserializer = new TimestampDeserializer(); long timestamp = deserializer.deserialize(parser, null); assertEquals(1480520820000L, timestamp); }
private static Part loadPart(int index, JsonParser parser, double location) throws IOException { if (parser.nextToken() != JsonToken.FIELD_NAME) { throw new IOException( "Field name expected."); } if (!Objects.equals(parser.getCurrentName(), "length")) { throw new IOException("length field expected."); } parser.nextToken(); double length = parser.getDoubleValue(); if (parser.nextToken() != JsonToken.FIELD_NAME) { throw new IOException("Field name expected."); } if (!Objects.equals(parser.getCurrentName(), "type")) { throw new IOException("type field expected."); } parser.nextToken(); String val = parser.getText(); Part.TYPE type; if (Objects.equals(val, "s")) { type = Part.TYPE.STRAIGHT; } else if (Objects.equals(val, "c")) { type = Part.TYPE.CURVED; } else { throw new IOException("Invalid part type detected."); } if (parser.nextToken() != JsonToken.END_OBJECT) { throw new IOException("Expected object to end."); } return new Part(index, type, length, location); }
@Override public Profile deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (p.getCurrentToken() == JsonToken.VALUE_STRING) { if (isImageApiProfile(p.getValueAsString())) { return new ImageApiProfile(p.getValueAsString()); } else { return new Profile(URI.create(p.getValueAsString())); } } else if (p.getCurrentToken() == JsonToken.START_OBJECT) { return p.getCodec().readValue(p, ImageApiProfile.class); } else { return (Profile) defaultDeserializer.deserialize(p, ctxt); } }
/** * Constructor used when calling a method for writing Type Id; * caller knows value object, its intended shape as well as id to * use; but not details of wrapping (if any). */ public WritableTypeId(Object value, JsonToken valueShape0, Object id0) { forValue = value; id = id0; valueShape = valueShape0; }
public DescribeKeyResult unmarshall(JsonUnmarshallerContext context) throws Exception { DescribeKeyResult describeKeyResult = new DescribeKeyResult(); int originalDepth = context.getCurrentDepth(); String currentParentElement = context.getCurrentParentElement(); int targetDepth = originalDepth + 1; JsonToken token = context.getCurrentToken(); if (token == null) token = context.nextToken(); if (token == VALUE_NULL) { return describeKeyResult; } while (true) { if (token == null) break; if (token == FIELD_NAME || token == START_OBJECT) { if (context.testExpression("KeyMetadata", targetDepth)) { context.nextToken(); describeKeyResult.setKeyMetadata(KeyMetadataJsonUnmarshaller.getInstance().unmarshall(context)); } } else if (token == END_ARRAY || token == END_OBJECT) { if (context.getLastParsedParentElement() == null || context.getLastParsedParentElement().equals(currentParentElement)) { if (context.getCurrentDepth() <= originalDepth) break; } } token = context.nextToken(); } return describeKeyResult; }
public void testUtf8Issue462() throws Exception { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); IOContext ioc = new IOContext(new BufferRecycler(), bytes, true); JsonGenerator gen = new UTF8JsonGenerator(ObjectWriteContext.empty(), ioc, 0, bytes, JsonFactory.DEFAULT_ROOT_VALUE_SEPARATOR, null, null); String str = "Natuurlijk is alles gelukt en weer een tevreden klant\uD83D\uDE04"; int length = 4000 - 38; for (int i = 1; i <= length; ++i) { gen.writeNumber(1); } gen.writeString(str); gen.flush(); gen.close(); // Also verify it's parsable? JsonParser p = JSON_F.createParser(ObjectReadContext.empty(), bytes.toByteArray()); for (int i = 1; i <= length; ++i) { assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken()); assertEquals(1, p.getIntValue()); } assertToken(JsonToken.VALUE_STRING, p.nextToken()); assertEquals(str, p.getText()); assertNull(p.nextToken()); p.close(); }
@Test public void testSexp() throws IOException { IonParser parser = parse("(a+b)"); assertEquals(JsonToken.START_ARRAY, parser.nextToken()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("a", parser.getText()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("+", parser.getText()); assertEquals(JsonToken.VALUE_STRING, parser.nextToken()); assertEquals("b", parser.getText()); assertEquals(JsonToken.END_ARRAY, parser.nextToken()); assertNull(parser.nextToken()); }
private void readRepository() throws IOException, ClassNotFoundException { ObjectRepository<?> repository = null; // move to [ parser.nextToken(); // loop till token equal to "]" while (parser.nextToken() != JsonToken.END_ARRAY) { // loop until end of collection object while (parser.nextToken() != JsonToken.END_OBJECT) { String fieldName = parser.getCurrentName(); if (TAG_TYPE.equals(fieldName)) { // move to next token parser.nextToken(); String typeId = parser.getText(); Class<?> type = Class.forName(typeId); repository = db.getRepository(type); } if (TAG_INDICES.equals(fieldName)) { readIndices(repository); } if (TAG_DATA.equals(fieldName) && repository != null) { readCollectionData(repository.getDocumentCollection()); } } } }
@Test public void testObjectLeadingComma() throws Exception { String json = "{,\"a\": true, \"b\": false}"; AsyncReaderWrapper p = createParser(factory, json); assertEquals(JsonToken.START_OBJECT, p.nextToken()); assertUnexpected(p, ','); p.close(); }
public static MajorType getFieldType(JsonToken token, boolean repeated) { if (repeated) { switch (token) { case VALUE_STRING: return REPEATED_STRING_TYPE; case VALUE_FALSE: case VALUE_TRUE: return REPEATED_BOOLEAN_TYPE; case START_ARRAY: return ARRAY_TYPE; case START_OBJECT: return MAP_TYPE; case VALUE_NUMBER_INT: return REPEATED_INT_TYPE; case VALUE_NUMBER_FLOAT: return REPEATED_FLOAT_TYPE; } } else { switch (token) { case VALUE_STRING: return STRING_TYPE; case VALUE_FALSE: case VALUE_TRUE: return BOOLEAN_TYPE; case START_ARRAY: return ARRAY_TYPE; case START_OBJECT: return MAP_TYPE; case VALUE_NUMBER_INT: return INT_TYPE; case VALUE_NUMBER_FLOAT: return FLOAT_TYPE; case VALUE_NULL: return NULL_TYPE; } } throw new UnsupportedOperationException("Unsupported Jackson type: " + token + ", Repeated: " + repeated); }