Java 类org.elasticsearch.common.xcontent.ObjectParser 实例源码

/**
 * we need to declare parse fields for each metadata field, except for _ID, _INDEX and _TYPE which are
 * handled individually. All other fields are parsed to an entry in the fields map
 */
private static void declareMetaDataFields(ObjectParser<Map<String, Object>, Void> parser) {
    for (String metadatafield : MapperService.getAllMetaFields()) {
        if (metadatafield.equals(Fields._ID) == false && metadatafield.equals(Fields._INDEX) == false
                && metadatafield.equals(Fields._TYPE) == false) {
            parser.declareField((map, field) -> {
                @SuppressWarnings("unchecked")
                Map<String, SearchHitField> fieldMap = (Map<String, SearchHitField>) map.computeIfAbsent(Fields.FIELDS,
                        v -> new HashMap<String, SearchHitField>());
                fieldMap.put(field.getName(), field);
            }, (p, c) -> {
                List<Object> values = new ArrayList<>();
                values.add(parseStoredFieldsValue(p));
                return new SearchHitField(metadatafield, values);
            }, new ParseField(metadatafield), ValueType.VALUE);
        }
    }
}

public static Aggregator.Parser getParser() {
    ObjectParser<AdjacencyMatrixAggregationBuilder, QueryParseContext> parser = new ObjectParser<>(
            AdjacencyMatrixAggregationBuilder.NAME);
    parser.declareString(AdjacencyMatrixAggregationBuilder::separator, SEPARATOR_FIELD);
    parser.declareNamedObjects(AdjacencyMatrixAggregationBuilder::setFiltersAsList, KeyedFilter.PARSER, FILTERS_FIELD);
    return new Aggregator.Parser() {
        @Override
        public AggregationBuilder parse(String aggregationName, QueryParseContext context) throws IOException {
            AdjacencyMatrixAggregationBuilder result = parser.parse(context.parser(),
                    new AdjacencyMatrixAggregationBuilder(aggregationName), context);
            result.checkConsistency();
            return result;
        }
    };
}

public static void declareInnerHitsParseFields(ObjectParser<Map<String, Object>, Void> parser) {
    declareMetaDataFields(parser);
    parser.declareString((map, value) -> map.put(Fields._TYPE, value), new ParseField(Fields._TYPE));
    parser.declareString((map, value) -> map.put(Fields._INDEX, value), new ParseField(Fields._INDEX));
    parser.declareString((map, value) -> map.put(Fields._ID, value), new ParseField(Fields._ID));
    parser.declareString((map, value) -> map.put(Fields._NODE, value), new ParseField(Fields._NODE));
    parser.declareField((map, value) -> map.put(Fields._SCORE, value), SearchHit::parseScore, new ParseField(Fields._SCORE),
            ValueType.FLOAT_OR_NULL);
    parser.declareLong((map, value) -> map.put(Fields._VERSION, value), new ParseField(Fields._VERSION));
    parser.declareField((map, value) -> map.put(Fields._SHARD, value), (p, c) -> ShardId.fromString(p.text()),
            new ParseField(Fields._SHARD), ValueType.STRING);
    parser.declareObject((map, value) -> map.put(SourceFieldMapper.NAME, value), (p, c) -> parseSourceBytes(p),
            new ParseField(SourceFieldMapper.NAME));
    parser.declareObject((map, value) -> map.put(Fields.HIGHLIGHT, value), (p, c) -> parseHighlightFields(p),
            new ParseField(Fields.HIGHLIGHT));
    parser.declareObject((map, value) -> {
        Map<String, SearchHitField> fieldMap = get(Fields.FIELDS, map, new HashMap<String, SearchHitField>());
        fieldMap.putAll(value);
        map.put(Fields.FIELDS, fieldMap);
    }, (p, c) -> parseFields(p), new ParseField(Fields.FIELDS));
    parser.declareObject((map, value) -> map.put(Fields._EXPLANATION, value), (p, c) -> parseExplanation(p),
            new ParseField(Fields._EXPLANATION));
    parser.declareObject((map, value) -> map.put(NestedIdentity._NESTED, value), NestedIdentity::fromXContent,
            new ParseField(NestedIdentity._NESTED));
    parser.declareObject((map, value) -> map.put(Fields.INNER_HITS, value), (p,c) -> parseInnerHits(p),
            new ParseField(Fields.INNER_HITS));
    parser.declareStringArray((map, list) -> map.put(Fields.MATCHED_QUERIES, list), new ParseField(Fields.MATCHED_QUERIES));
    parser.declareField((map, list) -> map.put(Fields.SORT, list), SearchSortValues::fromXContent, new ParseField(Fields.SORT),
            ValueType.OBJECT_ARRAY);
}

protected static <T extends Builder<?>> ObjectParser<T, Void> createAllocateParser(String command) {
    ObjectParser<T, Void> parser = new ObjectParser<>(command);
    parser.declareString(Builder::setIndex, new ParseField(INDEX_FIELD));
    parser.declareInt(Builder::setShard, new ParseField(SHARD_FIELD));
    parser.declareString(Builder::setNode, new ParseField(NODE_FIELD));
    return parser;
}

public static void declareAnyFields(
        ObjectParser<? extends ValuesSourceAggregationBuilder<ValuesSource, ?>, QueryParseContext> objectParser,
        boolean scriptable, boolean formattable) {
    declareFields(objectParser, scriptable, formattable, false, null);
}

public static void declareNumericFields(
        ObjectParser<? extends ValuesSourceAggregationBuilder<ValuesSource.Numeric, ?>, QueryParseContext> objectParser,
        boolean scriptable, boolean formattable, boolean timezoneAware) {
    declareFields(objectParser, scriptable, formattable, timezoneAware, ValueType.NUMERIC);
}

public static void declareBytesFields(
        ObjectParser<? extends ValuesSourceAggregationBuilder<ValuesSource.Bytes, ?>, QueryParseContext> objectParser,
        boolean scriptable, boolean formattable) {
    declareFields(objectParser, scriptable, formattable, false, ValueType.STRING);
}

public static void declareGeoFields(
        ObjectParser<? extends ValuesSourceAggregationBuilder<ValuesSource.GeoPoint, ?>, QueryParseContext> objectParser,
        boolean scriptable, boolean formattable) {
    declareFields(objectParser, scriptable, formattable, false, ValueType.GEOPOINT);
}

protected static void declareCommonFields(ObjectParser<? extends Entry<? extends Option>, Void> parser) {
    parser.declareString((entry, text) -> entry.text = new Text(text), new ParseField(TEXT));
    parser.declareInt((entry, offset) -> entry.offset = offset, new ParseField(OFFSET));
    parser.declareInt((entry, length) -> entry.length = length, new ParseField(LENGTH));
}

protected static <T extends Builder<?>> ObjectParser<T, Void> createAllocatePrimaryParser(String command) {
    ObjectParser<T, Void> parser = AbstractAllocateAllocationCommand.createAllocateParser(command);
    parser.declareBoolean(Builder::setAcceptDataLoss, new ParseField(ACCEPT_DATA_LOSS_FIELD));
    return parser;
}