public static void skipCurrentBlock(Parser parser) { int open = 1; while (true) { Token t = parser.nextToken(); if (t == null) { // handle EOF? return; } switch (t) { case START_OBJECT: case START_ARRAY: ++open; break; case END_OBJECT: case END_ARRAY: if (--open == 0) { return; } break; } } } }
@Override public Token nextToken() { Token token = delegate.nextToken(); updateLevelBasedOn(token); return token; }
/** * If this parser is reading tokens from an object or an array that is nested below its original * nesting level, it will consume and skip all tokens until it reaches the end of the block that * it was created on. The underlying parser will be left on the END_X token for the block. */ public void exitBlock() { if (open == 0) { return; } if (open < 0) { throw new IllegalStateException("Parser is no longer nested in any blocks at the level in which it was " + "created. You must create a new block aware parser to track the levels above this one."); } while (open > 0) { Token t = delegate.nextToken(); if (t == null) { // handle EOF? return; } updateLevelBasedOn(t); } }
protected Object list(String fieldName, String fieldMapping, Parser parser) { Token t = parser.currentToken(); if (t == null) { t = parser.nextToken(); } if (t == Token.START_ARRAY) { t = parser.nextToken(); } Object array = reader.createArray(mapping(fieldMapping, parser)); // create only one element since with fields, we always get arrays which create unneeded allocations List<Object> content = new ArrayList<Object>(1); for (; parser.currentToken() != Token.END_ARRAY;) { content.add(readListItem(fieldName, parser.currentToken(), fieldMapping, parser)); } // eliminate END_ARRAY parser.nextToken(); array = reader.addToArray(array, content); return array; }
private Object parseValue(Parser parser, FieldType esType) { Object obj; // special case of handing null (as text() will return "null") if (parser.currentToken() == Token.VALUE_NULL) { obj = null; } else { obj = reader.readValue(parser, parser.text(), esType); } parser.nextToken(); return obj; }
if (token == Token.START_OBJECT) { String relation = null; token = parser.nextToken(); while (token != Token.END_OBJECT) { if (token == Token.FIELD_NAME) { if ("value".equals(parser.currentName())) { parser.nextToken(); hits = parser.longValue(); } else if ("relation".equals(parser.currentName())) { parser.nextToken(); relation = parser.text(); } else { parser.nextToken(); token = parser.nextToken();
@Test public void testSkippingAtArrayStart() { String data = "{\"array\":[{\"test\":\"value\"}]}"; // ^--------------------^ Parser parser = new JacksonJsonParser(data.getBytes(Charset.defaultCharset())); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(parser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(parser.text(), equalTo("array")); assertThat(parser.nextToken(), equalTo(Parser.Token.START_ARRAY)); BlockAwareJsonParser blockParser = new BlockAwareJsonParser(parser); blockParser.exitBlock(); assertThat(parser.currentToken(), equalTo(Parser.Token.END_ARRAY)); assertThat(parser.nextToken(), equalTo(Parser.Token.END_OBJECT)); assertThat(parser.nextToken(), nullValue()); }
/** * In reality this test case is most likely not going to arise unless the underlying parser is used (Jackson * defends against invalid JSON already), but it is included for sanity and for code coverage. */ @Test public void testSkippingAndEncounterEOF() { String data = "{\"array\":[{\"test\":\"value\"}]}"; // ^ |X Parser parser = new JacksonJsonParser(data.getBytes(Charset.defaultCharset())); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(parser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(parser.text(), equalTo("array")); assertThat(parser.nextToken(), equalTo(Parser.Token.START_ARRAY)); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); BlockAwareJsonParser blockParser = new BlockAwareJsonParser(parser); // Improper use (using underlying parser instead of block parser) assertThat(parser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(parser.text(), equalTo("test")); assertThat(parser.nextToken(), equalTo(Parser.Token.VALUE_STRING)); assertThat(parser.text(), equalTo("value")); assertThat(parser.nextToken(), equalTo(Parser.Token.END_OBJECT)); assertThat(parser.nextToken(), equalTo(Parser.Token.END_ARRAY)); assertThat(parser.nextToken(), equalTo(Parser.Token.END_OBJECT)); blockParser.exitBlock(); assertThat(parser.currentToken(), nullValue()); } }
case FIELD_NAME: generator.writeFieldName(parser.currentName()); parser.nextToken(); traverse(parser, generator); break; case VALUE_STRING: generator.writeString(parser.text()); parser.nextToken(); break; case VALUE_BOOLEAN: generator.writeBoolean(parser.booleanValue()); parser.nextToken(); break; case VALUE_NULL: generator.writeNull(); parser.nextToken(); break; case VALUE_NUMBER: break; parser.nextToken(); break;
@Test public void testNoSkipping() { String data = "{\"test\":\"value\"}"; // ^X Parser parser = new JacksonJsonParser(data.getBytes(Charset.defaultCharset())); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(parser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(parser.text(), equalTo("test")); BlockAwareJsonParser blockParser = new BlockAwareJsonParser(parser); blockParser.exitBlock(); assertThat(parser.currentToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(parser.text(), equalTo("test")); }
@Test public void testSkippingArray() { String data = "{\"array\":[{\"test\":\"value\"}]}"; // ^ |-------------------^ Parser parser = new JacksonJsonParser(data.getBytes(Charset.defaultCharset())); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(parser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(parser.text(), equalTo("array")); BlockAwareJsonParser blockParser = new BlockAwareJsonParser(parser); assertThat(blockParser.nextToken(), equalTo(Parser.Token.START_ARRAY)); // assertThat(blockParser.tokenCharOffset(), equalTo(9)); // Doesn't quite work correctly? assertThat(blockParser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(blockParser.tokenCharOffset(), equalTo(10)); blockParser.exitBlock(); assertThat(blockParser.tokenCharOffset(), equalTo(26)); assertThat(parser.currentToken(), equalTo(Parser.Token.END_ARRAY)); assertThat(parser.nextToken(), equalTo(Parser.Token.END_OBJECT)); assertThat(parser.nextToken(), nullValue()); }
@Test public void testSkippingAtStart() { String data = "{\"test\":\"value\"}"; // ^ |-------------^ Parser parser = new JacksonJsonParser(data.getBytes(Charset.defaultCharset())); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); BlockAwareJsonParser blockParser = new BlockAwareJsonParser(parser); assertThat(blockParser.tokenCharOffset(), equalTo(0)); assertThat(blockParser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(blockParser.text(), equalTo("test")); blockParser.exitBlock(); assertThat(blockParser.tokenCharOffset(), equalTo(15)); assertThat(parser.currentToken(), equalTo(Parser.Token.END_OBJECT)); assertThat(parser.nextToken(), nullValue()); }
@Test public void testNonExistingToken() throws Exception { assertNull(ParsingUtils.seek(parser, "nosuchtoken")); assertNull(parser.nextToken()); }
@Test public void testSkipping() { String data = "{\"test\":\"value\"}"; // ^ |-------------^ Parser parser = new JacksonJsonParser(data.getBytes(Charset.defaultCharset())); BlockAwareJsonParser blockParser = new BlockAwareJsonParser(parser); assertThat(blockParser.tokenCharOffset(), equalTo(0)); assertThat(blockParser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(blockParser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(blockParser.text(), equalTo("test")); blockParser.exitBlock(); assertThat(blockParser.tokenCharOffset(), equalTo(15)); assertThat(parser.currentToken(), equalTo(Parser.Token.END_OBJECT)); assertThat(parser.nextToken(), nullValue()); }
@Test public void testSkippingOutOfScope() { String data = "{\"array\":[{\"test\":\"value\"}, {\"test2\":\"value2\"}]}"; // ^------------------^ X Parser parser = new JacksonJsonParser(data.getBytes(Charset.defaultCharset())); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(parser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(parser.text(), equalTo("array")); assertThat(parser.nextToken(), equalTo(Parser.Token.START_ARRAY)); assertThat(parser.nextToken(), equalTo(Parser.Token.START_OBJECT)); BlockAwareJsonParser blockParser = new BlockAwareJsonParser(parser); blockParser.exitBlock(); assertThat(blockParser.currentToken(), equalTo(Parser.Token.END_OBJECT)); assertThat(blockParser.nextToken(), equalTo(Parser.Token.START_OBJECT)); assertThat(blockParser.nextToken(), equalTo(Parser.Token.FIELD_NAME)); assertThat(blockParser.text(), equalTo("test2")); assertThat(blockParser.nextToken(), equalTo(Parser.Token.VALUE_STRING)); assertThat(blockParser.text(), equalTo("value2")); assertThat(blockParser.nextToken(), equalTo(Parser.Token.END_OBJECT)); assertThat(blockParser.nextToken(), equalTo(Parser.Token.END_ARRAY)); boolean failed = false; try { blockParser.exitBlock(); } catch (Exception e) { failed = true; } if (!failed) { fail("Should not have successfully exited a block out of scope of itself."); } }
@Test public void testFieldNestedButNotOnFirstLevel() throws Exception { assertNull(ParsingUtils.seek(parser, "state")); assertNull(parser.nextToken()); assertNull(parser.currentToken()); }