Java XContentParser.namedObject方法代码示例

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static Suggestion<? extends Entry<? extends Option>> fromXContent(XContentParser parser) throws IOException {
    ensureExpectedToken(XContentParser.Token.FIELD_NAME, parser.currentToken(), parser::getTokenLocation);
    String typeAndName = parser.currentName();
    // we need to extract the type prefix from the name and throw error if it is not present
    int delimiterPos = typeAndName.indexOf(InternalAggregation.TYPED_KEYS_DELIMITER);
    String type;
    String name;
    if (delimiterPos > 0) {
        type = typeAndName.substring(0, delimiterPos);
        name = typeAndName.substring(delimiterPos + 1);
    } else {
        throw new ParsingException(parser.getTokenLocation(),
                "Cannot parse suggestion response without type information. Set [" + RestSearchAction.TYPED_KEYS_PARAM
                        + "] parameter on the request to ensure the type information is added to the response output");
    }

    return parser.namedObject(Suggestion.class, type, name);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
static BaseCustomResponseSection fromXContent(XContentParser parser) throws IOException {
    assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
    assertEquals(XContentParser.Token.FIELD_NAME, parser.nextToken());
    BaseCustomResponseSection custom = parser.namedObject(BaseCustomResponseSection.class, parser.currentName(), null);
    assertEquals(XContentParser.Token.END_OBJECT, parser.nextToken());
    return custom;
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
static ExecutableSection parse(XContentParser parser) throws IOException {
    ParserUtils.advanceToFieldName(parser);
    String section = parser.currentName();
    XContentLocation location = parser.getTokenLocation();
    try {
        ExecutableSection executableSection = parser.namedObject(ExecutableSection.class, section, null);
        parser.nextToken();
        return executableSection;
    } catch (Exception e) {
        throw new IOException("Error parsing section starting at [" + location + "]", e);
    }
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
static SuggestionBuilder<?> fromXContent(XContentParser parser) throws IOException {
    XContentParser.Token token;
    String currentFieldName = null;
    String suggestText = null;
    String prefix = null;
    String regex = null;
    SuggestionBuilder<?> suggestionBuilder = null;

    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (TEXT_FIELD.match(currentFieldName)) {
                suggestText = parser.text();
            } else if (PREFIX_FIELD.match(currentFieldName)) {
                prefix = parser.text();
            } else if (REGEX_FIELD.match(currentFieldName)) {
                regex = parser.text();
            } else {
                throw new ParsingException(parser.getTokenLocation(), "suggestion does not support [" + currentFieldName + "]");
            }
        } else if (token == XContentParser.Token.START_OBJECT) {
            suggestionBuilder = parser.namedObject(SuggestionBuilder.class, currentFieldName, null);
        }
    }
    if (suggestionBuilder == null) {
        throw new ElasticsearchParseException("missing suggestion object");
    }
    if (suggestText != null) {
        suggestionBuilder.text(suggestText);
    }
    if (prefix != null) {
        suggestionBuilder.prefix(prefix);
    }
    if (regex != null) {
        suggestionBuilder.regex(regex);
    }
    return suggestionBuilder;
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public static MetaData fromXContent(XContentParser parser) throws IOException {
    Builder builder = new Builder();

    // we might get here after the meta-data element, or on a fresh parser
    XContentParser.Token token = parser.currentToken();
    String currentFieldName = parser.currentName();
    if (!"meta-data".equals(currentFieldName)) {
        token = parser.nextToken();
        if (token == XContentParser.Token.START_OBJECT) {
            // move to the field name (meta-data)
            token = parser.nextToken();
            if (token != XContentParser.Token.FIELD_NAME) {
                throw new IllegalArgumentException("Expected a field name but got " + token);
            }
            // move to the next object
            token = parser.nextToken();
        }
        currentFieldName = parser.currentName();
    }

    if (!"meta-data".equals(parser.currentName())) {
        throw new IllegalArgumentException("Expected [meta-data] as a field name but got " + currentFieldName);
    }
    if (token != XContentParser.Token.START_OBJECT) {
        throw new IllegalArgumentException("Expected a START_OBJECT but got " + token);
    }

    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token == XContentParser.Token.START_OBJECT) {
            if ("settings".equals(currentFieldName)) {
                builder.persistentSettings(Settings.builder().put(SettingsLoader.Helper.loadNestedFromMap(parser.mapOrdered())).build());
            } else if ("indices".equals(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                    builder.put(IndexMetaData.Builder.fromXContent(parser), false);
                }
            } else if ("templates".equals(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                    builder.put(IndexTemplateMetaData.Builder.fromXContent(parser, parser.currentName()));
                }
            } else {
                try {
                    Custom custom = parser.namedObject(Custom.class, currentFieldName, null);
                    builder.putCustom(custom.getWriteableName(), custom);
                } catch (UnknownNamedObjectException ex) {
                    logger.warn("Skipping unknown custom object with type {}", currentFieldName);
                    parser.skipChildren();
                }
            }
        } else if (token.isValue()) {
            if ("version".equals(currentFieldName)) {
                builder.version = parser.longValue();
            } else if ("cluster_uuid".equals(currentFieldName) || "uuid".equals(currentFieldName)) {
                builder.clusterUUID = parser.text();
            } else {
                throw new IllegalArgumentException("Unexpected field [" + currentFieldName + "]");
            }
        } else {
            throw new IllegalArgumentException("Unexpected token " + token);
        }
    }
    return builder.build();
}