Java Token类代码示例

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
/**
 * Since inline scripts can accept code rather than just an id, they must also be able
 * to handle template parsing, hence the need for custom parsing code.  Templates can
 * consist of either an {@link String} or a JSON object.  If a JSON object is discovered
 * then the content type option must also be saved as a compiler option.
 */
private void setInline(XContentParser parser) {
    try {
        if (type != null) {
            throwOnlyOneOfType();
        }

        type = ScriptType.INLINE;

        if (parser.currentToken() == Token.START_OBJECT) {
            //this is really for search templates, that need to be converted to json format
            XContentBuilder builder = XContentFactory.jsonBuilder();
            idOrCode = builder.copyCurrentStructure(parser).string();
            options.put(CONTENT_TYPE_OPTION, XContentType.JSON.mediaType());
        } else {
            idOrCode = parser.text();
        }
    } catch (IOException exception) {
        throw new UncheckedIOException(exception);
    }
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
private static InternalOrder parseOrder(XContentParser parser, QueryParseContext context) throws IOException {
    InternalOrder order = null;
    Token token;
    String currentFieldName = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token == XContentParser.Token.VALUE_STRING) {
            String dir = parser.text();
            boolean asc = "asc".equals(dir);
            if (!asc && !"desc".equals(dir)) {
                throw new ParsingException(parser.getTokenLocation(), "Unknown order direction: [" + dir
                        + "]. Should be either [asc] or [desc]");
            }
            order = resolveOrder(currentFieldName, asc);
        }
    }
    return order;
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
public void testParseGeoPointGeohash() throws IOException {
    for (int i = 0; i < 100; i++) {
        int geoHashLength = randomIntBetween(1, GeoHashUtils.PRECISION);
        StringBuilder geohashBuilder = new StringBuilder(geoHashLength);
        for (int j = 0; j < geoHashLength; j++) {
            geohashBuilder.append(BASE_32[randomInt(BASE_32.length - 1)]);
        }
        XContentBuilder json = jsonBuilder().startObject().field("geohash", geohashBuilder.toString()).endObject();
        XContentParser parser = createParser(json);
        parser.nextToken();
        GeoPoint point = GeoUtils.parseGeoPoint(parser);
        assertThat(point.lat(), allOf(lessThanOrEqualTo(90.0), greaterThanOrEqualTo(-90.0)));
        assertThat(point.lon(), allOf(lessThanOrEqualTo(180.0), greaterThanOrEqualTo(-180.0)));
        json = jsonBuilder().startObject().field("geohash", geohashBuilder.toString()).endObject();
        parser = createParser(json);
        while (parser.currentToken() != Token.VALUE_STRING) {
            parser.nextToken();
        }
        point = GeoUtils.parseGeoPoint(parser);
        assertThat(point.lat(), allOf(lessThanOrEqualTo(90.0), greaterThanOrEqualTo(-90.0)));
        assertThat(point.lon(), allOf(lessThanOrEqualTo(180.0), greaterThanOrEqualTo(-180.0)));
    }
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
private String verifyNodeDecisionPrologue(XContentParser parser) throws IOException {
    assertEquals(Token.START_OBJECT, parser.nextToken());
    parser.nextToken();
    assertEquals("node_id", parser.currentName());
    parser.nextToken();
    assertNotNull(parser.text());
    parser.nextToken();
    assertEquals("node_name", parser.currentName());
    parser.nextToken();
    String nodeName = parser.text();
    assertNotNull(nodeName);
    parser.nextToken();
    assertEquals("transport_address", parser.currentName());
    parser.nextToken();
    assertNotNull(parser.text());
    parser.nextToken();
    assertEquals("node_decision", parser.currentName());
    parser.nextToken();
    return nodeName;
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
private boolean verifyDeciders(XContentParser parser, AllocationDecision allocationDecision) throws IOException {
    assertEquals(Token.START_ARRAY, parser.nextToken());
    boolean atLeastOneMatchingDecisionFound = false;
    while (parser.nextToken() != Token.END_ARRAY) {
        assertEquals(Token.START_OBJECT, parser.currentToken());
        parser.nextToken();
        assertEquals("decider", parser.currentName());
        parser.nextToken();
        assertNotNull(parser.text());
        parser.nextToken();
        assertEquals("decision", parser.currentName());
        parser.nextToken();
        String decisionText = parser.text();
        if ((allocationDecision == AllocationDecision.NO && decisionText.equals("NO")
                 || (allocationDecision == AllocationDecision.THROTTLED && decisionText.equals("THROTTLE")))) {
            atLeastOneMatchingDecisionFound = true;
        }
        assertNotNull(decisionText);
        parser.nextToken();
        assertEquals("explanation", parser.currentName());
        parser.nextToken();
        assertNotNull(parser.text());
        assertEquals(Token.END_OBJECT, parser.nextToken());
    }
    return atLeastOneMatchingDecisionFound;
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
@Override
public FieldQuery parseQuery(String name, XContentParser parser) throws IOException, ElasticsearchParseException {
    Iterable<? extends CharSequence> values;
    Token token = parser.currentToken();
    if (token == Token.START_ARRAY) {
        ArrayList<String> list = new ArrayList<>();
        while ((token = parser.nextToken()) != Token.END_ARRAY) {
            list.add(parser.text());
        }
        values = list;
    } else if (token == Token.VALUE_NULL) {
        values = defaultValues;
    } else {
        values = Collections.singleton(parser.text());
    }

    return new FieldQuery(name, values);
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
    XContentParser parser = parseContext.parser();

    Token token = parser.nextToken();
    if (!MATCH_NAME.equals(parser.currentName()) || token != XContentParser.Token.FIELD_NAME) {
        throw new QueryParsingException(parseContext, "spanMultiTerm must have [" + MATCH_NAME + "] multi term query clause");
    }

    token = parser.nextToken();
    if (token != XContentParser.Token.START_OBJECT) {
        throw new QueryParsingException(parseContext, "spanMultiTerm must have [" + MATCH_NAME + "] multi term query clause");
    }

    Query subQuery = parseContext.parseInnerQuery();
    if (!(subQuery instanceof MultiTermQuery)) {
        throw new QueryParsingException(parseContext, "spanMultiTerm [" + MATCH_NAME + "] must be of type multi term query");
    }

    parser.nextToken();
    return new SpanMultiTermQueryWrapper<>((MultiTermQuery) subQuery);
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
public static Term parse(XContentParser parser, String name) {
    try {
        Term completion = new Term(name);
        Token token;
        String currentFieldName = null;
        while ((token = parser.nextToken()) != END_OBJECT) {
            if (token == FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else if (token.isValue()) {
                if("text".equals(currentFieldName)) {
                    completion.text = parser.text();
                } else if("offset".equals(currentFieldName)) {
                    completion.offset = parser.intValue();
                } else if("length".equals(currentFieldName)) {
                    completion.length = parser.intValue();
                }
            } else if (token == START_ARRAY && "options".equals(currentFieldName)) {
                completion.options = parseOptions(parser);
            }
        }
        return completion;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
protected static Option parseOption(XContentParser parser) throws IOException {
    Token token;
    String currentFieldName = null;
    Option option = new Option();
    while ((token = parser.nextToken()) != Token.END_OBJECT) {
        if (token == Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if ("text".equals(currentFieldName)) {
                option.text = parser.text();
            } else if ("freq".equals(currentFieldName)) {
                option.freq = parser.longValue();
            } else if ("score".equals(currentFieldName)) {
                option.score = parser.floatValue();
            }
        }
    }
    return option;
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
public static Completion parse(XContentParser parser, String name) {
    try {
        Completion completion = new Completion(name);
        Token token;
        String currentFieldName = null;
        while ((token = parser.nextToken()) != END_OBJECT) {
            if (token == FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else if (token.isValue()) {
                if("text".equals(currentFieldName)) {
                    completion.text = parser.text();
                } else if("offset".equals(currentFieldName)) {
                    completion.offset = parser.intValue();
                } else if("length".equals(currentFieldName)) {
                    completion.length = parser.intValue();
                }
            } else if (token == START_ARRAY && "options".equals(currentFieldName)) {
                completion.options = parseOptions(parser);
            }
        }
        return completion;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
protected static Option parseOption(XContentParser parser) throws IOException {
    Token token;
    String currentFieldName = null;
    Option option = new Option();
    while ((token = parser.nextToken()) != Token.END_OBJECT) {
        if (token == Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if ("text".equals(currentFieldName)) {
                option.text = parser.text();
            } else if ("score".equals(currentFieldName)) {
                option.score = parser.floatValue();
            }
        } else if (token == Token.START_OBJECT && "payload".equals(currentFieldName)) {
            try (XContentBuilder docBuilder = XContentFactory.contentBuilder(XContentType.JSON)) {
                docBuilder.copyCurrentStructure(parser);
                option.payload = docBuilder.bytes().toUtf8();
            }
        }
    }
    return option;
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
public static Phrase parse(XContentParser parser, String name) {
    try {
        Phrase completion = new Phrase(name);
        Token token;
        String currentFieldName = null;
        while ((token = parser.nextToken()) != END_OBJECT) {
            if (token == FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else if (token.isValue()) {
                if("text".equals(currentFieldName)) {
                    completion.text = parser.text();
                } else if("offset".equals(currentFieldName)) {
                    completion.offset = parser.intValue();
                } else if("length".equals(currentFieldName)) {
                    completion.length = parser.intValue();
                }
            } else if (token == START_ARRAY && "options".equals(currentFieldName)) {
                completion.options = parseOptions(parser);
            }
        }
        return completion;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
protected static Option parseOption(XContentParser parser) throws IOException {
    Token token;
    String currentFieldName = null;
    Option option = new Option();
    while ((token = parser.nextToken()) != Token.END_OBJECT) {
        if (token == Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if ("text".equals(currentFieldName)) {
                option.text = parser.text();
            } else if ("collate".equals(currentFieldName)) {
                option.collate = parser.booleanValue();
            } else if ("score".equals(currentFieldName)) {
                option.score = parser.floatValue();
            } else if ("highlighted".equals(currentFieldName)) {
                option.highlighted = parser.text();
            }
        }
    }
    return option;
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
public JobEvent fromXContent(XContentParser parser) throws IOException {
    //DateMathParser dateParser = new DateMathParser(Joda.forPattern("dateOptionalTime"), TimeUnit.MILLISECONDS);
    Long startTimestamp = null;
    String currentFieldName = null;
    Token token;
    while ((token = parser.nextToken()) != END_OBJECT) {
        if (token == FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue() || token == VALUE_NULL) {
            if ("started".equals(currentFieldName)) {
                startTimestamp =  Long.parseLong(parser.text());
            }
        } else if (token == START_ARRAY) {
            List<String> values = newArrayList();
            while ((parser.nextToken()) != END_ARRAY) {
                values.add(parser.text());
            }
        }
    }
    return new JobEvent().timestamp(startTimestamp);
}
 

import org.elasticsearch.common.xcontent.XContentParser.Token; //导入依赖的package包/类
/**
 * Since stored scripts can accept templates rather than just scripts, they must also be able
 * to handle template parsing, hence the need for custom parsing code.  Templates can
 * consist of either an {@link String} or a JSON object.  If a JSON object is discovered
 * then the content type option must also be saved as a compiler option.
 */
private void setCode(XContentParser parser) {
    try {
        if (parser.currentToken() == Token.START_OBJECT) {
            //this is really for search templates, that need to be converted to json format
            XContentBuilder builder = XContentFactory.jsonBuilder();
            code = builder.copyCurrentStructure(parser).string();
            options.put(Script.CONTENT_TYPE_OPTION, XContentType.JSON.mediaType());
        } else {
            code = parser.text();
        }
    } catch (IOException exception) {
        throw new UncheckedIOException(exception);
    }
}