@Override public void close() { delegate.close(); }
private static void traverse(Parser parser, Generator generator) { Token t = parser.currentToken(); switch (t) { case START_OBJECT: break; 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: switch (parser.numberType()) { case INT: generator.writeNumber(parser.intValue()); break; case LONG: generator.writeNumber(parser.longValue());
Token t = parser.currentToken(); t = parser.nextToken(); int metadataStartChar = parser.tokenCharOffset(); int metadataStopChar = -1; int endCharOfLastElement = -1; while ((t = parser.currentToken()) != null) { name = parser.currentName(); absoluteName = StringUtils.stripFieldNameSourcePrefix(parser.absoluteName()); t = parser.nextToken(); id = reader.wrapString(parser.text()); endCharOfLastElement = parser.tokenCharOffset(); t = parser.nextToken(); t = parser.nextToken(); break; parser.skipChildren(); parser.nextToken(); t = parser.nextToken(); endCharOfLastElement = parser.tokenCharOffset(); String absoluteName = StringUtils.stripFieldNameSourcePrefix(parser.absoluteName()); reader.beginField(absoluteName); result[0] = reader.wrapString(parser.text());
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; }
private static void traverseMap(Parser parser, Generator generator) { generator.writeBeginObject(); parser.nextToken(); for (; parser.currentToken() != Token.END_OBJECT;) { traverse(parser, generator); } generator.writeEndObject(); parser.nextToken(); }
token = parser.currentToken(); if (token == null) { token = parser.nextToken(); while ((token = parser.nextToken()) != null) { if (token == Token.START_OBJECT) { token = parser.nextToken(); currentName = parser.currentName(); if (path1 != null && currentName.equals(path1[index1])) { if (index1 + 1 < path1.length) { return parser.nextToken(); return parser.nextToken(); parser.nextToken(); parser.skipChildren();
private static void doFind(Parser parser, List<Matcher> currentMatchers, int level, int maxNesting) { Token token = parser.currentToken(); if (token == null) { parser.nextToken(); while ((token = parser.nextToken()) != null && token != Token.END_OBJECT) { if (token == Token.FIELD_NAME) { String currentName = parser.currentName(); Object value = null; boolean valueRead = false; if (!valueRead) { valueRead = true; switch (parser.nextToken()) { case VALUE_NUMBER: value = parser.numberValue(); break; case VALUE_BOOLEAN: value = Boolean.valueOf(parser.booleanValue()); break; case VALUE_NULL: break; case VALUE_STRING: value = parser.text(); break; default: switch (parser.nextToken()) {
protected Object map(String fieldMapping, Parser parser) { Token t = parser.currentToken(); t = parser.nextToken(); t = parser.nextToken(); for (; parser.currentToken() != Token.END_OBJECT;) { String currentName = parser.currentName(); String nodeMapping = fieldMapping; String absoluteName = StringUtils.stripFieldNameSourcePrefix(parser.absoluteName()); Token nt = parser.nextToken(); if (nt.isValue()) { parser.nextToken(); parser.nextToken(); reader.addToMap(map, fieldName, read(absoluteName, parser.nextToken(), nodeMapping, parser)); reader.endField(absoluteName); parser.nextToken();
Token token = parser.currentToken(); 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(); parser.skipChildren(); token = parser.nextToken(); hits = parser.longValue();
protected Object booleanValue(String value, Parser parser) { Boolean val = null; if (value == null) { return nullValue(); } else { Token tk = parser.currentToken(); if (tk == Token.VALUE_NULL) { return nullValue(); } if (tk == Token.VALUE_BOOLEAN) { val = parser.booleanValue(); } else if (tk == Token.VALUE_NUMBER) { val = parser.intValue() != 0; } else { val = parseBoolean(value); } } return processBoolean(val); }
protected Object doubleValue(String value, Parser parser) { Double val = null; if (value == null || isEmpty(value)) { return nullValue(); } else { Token tk = parser.currentToken(); if (tk == Token.VALUE_NUMBER) { val = parser.doubleValue(); } else { val = parseDouble(value); } } return processDouble(val); }
Token currentToken = parser.currentToken(); if (!currentToken.isValue()) { break; case VALUE_NUMBER: NumberType numberType = parser.numberType(); switch (numberType) { case INT:
@Test public void testOneLevelNestedField() throws Exception { assertNotNull(ParsingUtils.seek(parser, "address.state")); assertEquals(Token.VALUE_STRING, parser.currentToken()); assertEquals("state", parser.currentName()); }
@Override public byte[] binaryValue() { return delegate.binaryValue(); }
protected Object intValue(String value, Parser parser) { Integer val = null; if (value == null || isEmpty(value)) { return nullValue(); } else { Token tk = parser.currentToken(); if (tk == Token.VALUE_NUMBER) { val = parser.intValue(); } else { val = parseInteger(value); } } return processInteger(val); }
@Override public NumberType numberType() { return delegate.numberType(); }
@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."); } }
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 String currentName() { return delegate.currentName(); }
public BlockAwareJsonParser(Parser delegate) { this.delegate = delegate; Token currentToken = delegate.currentToken(); if (currentToken != null && (currentToken == Token.START_OBJECT || currentToken == Token.START_ARRAY)) { this.open = 1; // start assuming that we are nested if the current parser token is a block start. } }