Java Token.END_ARRAY属性代码示例

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;
}
 

@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);
}
 

/**
 * Parses query contexts for this mapper
 */
public final List<InternalQueryContext> parseQueryContext(QueryParseContext context) throws IOException, ElasticsearchParseException {
    List<T> queryContexts = new ArrayList<>();
    XContentParser parser = context.parser();
    Token token = parser.nextToken();
    if (token == Token.START_OBJECT || token == Token.VALUE_STRING) {
        queryContexts.add(fromXContent(context));
    } else if (token == Token.START_ARRAY) {
        while (parser.nextToken() != Token.END_ARRAY) {
            queryContexts.add(fromXContent(context));
        }
    }
    return toInternalQueryContexts(queryContexts);
}
 

protected static Collection<String> parseSinglePointOrList(XContentParser parser) throws IOException {
    Token token = parser.currentToken();
    if(token == Token.START_ARRAY) {
        token = parser.nextToken();
        // Test if value is a single point in <code>[lon, lat]</code> format
        if(token == Token.VALUE_NUMBER) {
            double lon = parser.doubleValue();
            if(parser.nextToken() == Token.VALUE_NUMBER) {
                double lat = parser.doubleValue();
                if(parser.nextToken() == Token.END_ARRAY) {
                    return Collections.singleton(GeoHashUtils.stringEncode(lon, lat));
                } else {
                    throw new ElasticsearchParseException("only two values expected");
                }
            } else {
                throw new ElasticsearchParseException("latitue must be a numeric value");
            }
        } else {
            // otherwise it's a list of locations
            ArrayList<String> result = new ArrayList<>();
            while (token != Token.END_ARRAY) {
                result.add(GeoUtils.parseGeoPoint(parser).geohash());
                token = parser.nextToken(); //infinite loop without this line
            }
            return result;
        }
    } else {
        // or a single location
        return Collections.singleton(GeoUtils.parseGeoPoint(parser).geohash());
    }
}
 

protected static List<Option> parseOptions(XContentParser parser) throws IOException {
    Token token;
    List<Option> result = new ArrayList<>();
    while ((token = parser.nextToken()) != Token.END_ARRAY) {
        if (token == Token.START_OBJECT) {
            result.add(parseOption(parser));
        }
    }
    return result;
}
 

public static GeoPolygonQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();

    String fieldName = null;

    List<GeoPoint> shell = null;

    Float boost = null;
    GeoValidationMethod validationMethod = null;
    String queryName = null;
    String currentFieldName = null;
    XContentParser.Token token;
    boolean ignoreUnmapped = DEFAULT_IGNORE_UNMAPPED;

    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (parseContext.isDeprecatedSetting(currentFieldName)) {
            // skip
        } else if (token == XContentParser.Token.START_OBJECT) {
            fieldName = currentFieldName;

            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token == XContentParser.Token.START_ARRAY) {
                    if (POINTS_FIELD.match(currentFieldName)) {
                        shell = new ArrayList<GeoPoint>();
                        while ((token = parser.nextToken()) != Token.END_ARRAY) {
                            shell.add(GeoUtils.parseGeoPoint(parser));
                        }
                    } else {
                        throw new ParsingException(parser.getTokenLocation(),
                                "[geo_polygon] query does not support [" + currentFieldName + "]");
                    }
                } else {
                    throw new ParsingException(parser.getTokenLocation(),
                            "[geo_polygon] query does not support token type [" + token.name() + "] under [" + currentFieldName + "]");
                }
            }
        } else if (token.isValue()) {
            if ("_name".equals(currentFieldName)) {
                queryName = parser.text();
            } else if ("boost".equals(currentFieldName)) {
                boost = parser.floatValue();
            } else if (IGNORE_UNMAPPED_FIELD.match(currentFieldName)) {
                ignoreUnmapped = parser.booleanValue();
            } else if (VALIDATION_METHOD.match(currentFieldName)) {
                validationMethod = GeoValidationMethod.fromString(parser.text());
            } else {
                throw new ParsingException(parser.getTokenLocation(),
                        "[geo_polygon] query does not support [" + currentFieldName + "]");
            }
        } else {
            throw new ParsingException(parser.getTokenLocation(), "[geo_polygon] unexpected token type [" + token.name() + "]");
        }
    }
    GeoPolygonQueryBuilder builder = new GeoPolygonQueryBuilder(fieldName, shell);
    if (validationMethod != null) {
        // if GeoValidationMethod was explicitly set ignore deprecated coerce and ignoreMalformed settings
        builder.setValidationMethod(validationMethod);
    }

    if (queryName != null) {
        builder.queryName(queryName);
    }
    if (boost != null) {
        builder.boost(boost);
    }
    builder.ignoreUnmapped(ignoreUnmapped);
    return builder;
}