Java XContentParser.longValue方法代码示例

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public static CollectorResult fromXContent(XContentParser parser) throws IOException {
    XContentParser.Token token = parser.currentToken();
    ensureExpectedToken(XContentParser.Token.START_OBJECT, token, parser::getTokenLocation);
    String currentFieldName = null;
    String name = null, reason = null;
    long time = -1;
    List<CollectorResult> children = new ArrayList<>();
    while((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (NAME.match(currentFieldName)) {
                name = parser.text();
            } else if (REASON.match(currentFieldName)) {
                reason = parser.text();
            } else if (TIME.match(currentFieldName)) {
                // we need to consume this value, but we use the raw nanosecond value
                parser.text();
            } else if (TIME_NANOS.match(currentFieldName)) {
                time = parser.longValue();
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else if (token == XContentParser.Token.START_ARRAY) {
            if (CHILDREN.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    children.add(CollectorResult.fromXContent(parser));
                }
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else {
            throwUnknownToken(token, parser.getTokenLocation());
        }
    }
    return new CollectorResult(name, reason, time, children);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public static QueryProfileShardResult fromXContent(XContentParser parser) throws IOException {
    XContentParser.Token token = parser.currentToken();
    ensureExpectedToken(XContentParser.Token.START_OBJECT, token, parser::getTokenLocation);
    String currentFieldName = null;
    List<ProfileResult> queryProfileResults = new ArrayList<>();
    long rewriteTime = 0;
    CollectorResult collector = null;
    while((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (REWRITE_TIME.equals(currentFieldName)) {
                rewriteTime = parser.longValue();
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else if (token == XContentParser.Token.START_ARRAY) {
            if (QUERY_ARRAY.equals(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    queryProfileResults.add(ProfileResult.fromXContent(parser));
                }
            } else if (COLLECTOR.equals(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    collector = CollectorResult.fromXContent(parser);
                }
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else {
            throwUnknownToken(token, parser.getTokenLocation());
        }
    }
    return new QueryProfileShardResult(queryProfileResults, rewriteTime, collector);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public static SearchHits fromXContent(XContentParser parser) throws IOException {
    if (parser.currentToken() != XContentParser.Token.START_OBJECT) {
        parser.nextToken();
        ensureExpectedToken(XContentParser.Token.START_OBJECT, parser.currentToken(), parser::getTokenLocation);
    }
    XContentParser.Token token = parser.currentToken();
    String currentFieldName = null;
    List<SearchHit> hits = new ArrayList<>();
    long totalHits = 0;
    float maxScore = 0f;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (Fields.TOTAL.equals(currentFieldName)) {
                totalHits = parser.longValue();
            } else if (Fields.MAX_SCORE.equals(currentFieldName)) {
                maxScore = parser.floatValue();
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else if (token == XContentParser.Token.VALUE_NULL) {
            if (Fields.MAX_SCORE.equals(currentFieldName)) {
                maxScore = Float.NaN; // NaN gets rendered as null-field
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else if (token == XContentParser.Token.START_ARRAY) {
            while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                hits.add(SearchHit.fromXContent(parser));
            }
        }
    }
    SearchHits searchHits = new SearchHits(hits.toArray(new SearchHit[hits.size()]), totalHits,
            maxScore);
    return searchHits;
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public static BulkResponse fromXContent(XContentParser parser) throws IOException {
    XContentParser.Token token = parser.nextToken();
    ensureExpectedToken(XContentParser.Token.START_OBJECT, token, parser::getTokenLocation);

    long took = -1L;
    long ingestTook = NO_INGEST_TOOK;
    List<BulkItemResponse> items = new ArrayList<>();

    String currentFieldName = parser.currentName();
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (TOOK.equals(currentFieldName)) {
                took = parser.longValue();
            } else if (INGEST_TOOK.equals(currentFieldName)) {
                ingestTook = parser.longValue();
            } else if (ERRORS.equals(currentFieldName) == false) {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else if (token == XContentParser.Token.START_ARRAY) {
            if (ITEMS.equals(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    items.add(BulkItemResponse.fromXContent(parser, items.size()));
                }
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else {
            throwUnknownToken(token, parser.getTokenLocation());
        }
    }
    return new BulkResponse(items.toArray(new BulkItemResponse[items.size()]), took, ingestTook);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public DummyState parse(XContentParser parser) throws IOException {
    String fieldName = null;
    parser.nextToken();  // start object
    while(parser.nextToken() != XContentParser.Token.END_OBJECT) {
        XContentParser.Token token = parser.currentToken();
        if (token == XContentParser.Token.FIELD_NAME) {
          fieldName = parser.currentName();
        } else if (token == XContentParser.Token.VALUE_STRING) {
            assertTrue("string".equals(fieldName));
            string = parser.text();
        } else if (token == XContentParser.Token.VALUE_NUMBER) {
            switch (fieldName) {
                case "double":
                    aDouble = parser.doubleValue();
                    break;
                case "int":
                    aInt = parser.intValue();
                    break;
                case "long":
                    aLong = parser.longValue();
                    break;
                default:
                    fail("unexpected numeric value " + token);
                    break;
            }
        }else if (token == XContentParser.Token.VALUE_BOOLEAN) {
            assertTrue("boolean".equals(fieldName));
            aBoolean = parser.booleanValue();
        } else {
            fail("unexpected value " + token);
        }
    }
    return this;
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
@Override
public AggregatorFactory parse(String name, XContentParser parser, SearchContext context) throws IOException {

    ValuesSourceParser<?> vsParser = ValuesSourceParser.any(name, InternalCardinality.TYPE, context).formattable(false).build();

    long precisionThreshold = -1;

    XContentParser.Token token;
    String currentFieldName = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (vsParser.token(currentFieldName, token, parser)) {
            continue;
        } else if (token.isValue()) {
            if (context.parseFieldMatcher().match(currentFieldName, REHASH)) {
                // ignore
            } else if (context.parseFieldMatcher().match(currentFieldName, PRECISION_THRESHOLD)) {
                precisionThreshold = parser.longValue();
            } else {
                throw new SearchParseException(context, "Unknown key for a " + token + " in [" + name + "]: [" + currentFieldName
                        + "].", parser.getTokenLocation());
            }
        } else {
            throw new SearchParseException(context, "Unexpected token " + token + " in [" + name + "].", parser.getTokenLocation());
        }
    }

    return new CardinalityAggregatorFactory(name, vsParser.config(), precisionThreshold);

}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
@Override
public ShardStateMetaData fromXContent(XContentParser parser) throws IOException {
    XContentParser.Token token = parser.nextToken();
    if (token == null) {
        return null;
    }
    long version = -1;
    Boolean primary = null;
    String currentFieldName = null;
    String indexUUID = IndexMetaData.INDEX_UUID_NA_VALUE;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (VERSION_KEY.equals(currentFieldName)) {
                version = parser.longValue();
            } else if (PRIMARY_KEY.equals(currentFieldName)) {
                primary = parser.booleanValue();
            } else if (INDEX_UUID_KEY.equals(currentFieldName)) {
                indexUUID = parser.text();
            } else {
                throw new CorruptStateException("unexpected field in shard state [" + currentFieldName + "]");
            }
        } else {
            throw new CorruptStateException("unexpected token in shard state [" + token.name() + "]");
        }
    }
    if (primary == null) {
        throw new CorruptStateException("missing value for [primary] in shard state");
    }
    if (version == -1) {
        throw new CorruptStateException("missing value for [version] in shard state");
    }
    return new ShardStateMetaData(version, primary, indexUUID);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
static Object readValue(XContentParser parser, MapFactory mapFactory, XContentParser.Token token) throws IOException {
    if (token == XContentParser.Token.VALUE_NULL) {
        return null;
    } else if (token == XContentParser.Token.VALUE_STRING) {
        return parser.text();
    } else if (token == XContentParser.Token.VALUE_NUMBER) {
        XContentParser.NumberType numberType = parser.numberType();
        if (numberType == XContentParser.NumberType.INT) {
            return parser.intValue();
        } else if (numberType == XContentParser.NumberType.LONG) {
            return parser.longValue();
        } else if (numberType == XContentParser.NumberType.FLOAT) {
            return parser.floatValue();
        } else if (numberType == XContentParser.NumberType.DOUBLE) {
            return parser.doubleValue();
        }
    } else if (token == XContentParser.Token.VALUE_BOOLEAN) {
        return parser.booleanValue();
    } else if (token == XContentParser.Token.START_OBJECT) {
        return readMap(parser, mapFactory);
    } else if (token == XContentParser.Token.START_ARRAY) {
        return readList(parser, mapFactory);
    } else if (token == XContentParser.Token.VALUE_EMBEDDED_OBJECT) {
        return parser.binaryValue();
    }
    return null;
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public static ProfileResult fromXContent(XContentParser parser) throws IOException {
    XContentParser.Token token = parser.currentToken();
    ensureExpectedToken(XContentParser.Token.START_OBJECT, token, parser::getTokenLocation);
    String currentFieldName = null;
    String type = null, description = null;
    Map<String, Long> timings =  new HashMap<>();
    List<ProfileResult> children = new ArrayList<>();
    while((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (TYPE.match(currentFieldName)) {
                type = parser.text();
            } else if (DESCRIPTION.match(currentFieldName)) {
                description = parser.text();
            } else if (NODE_TIME.match(currentFieldName)) {
                // skip, total time is calculate by adding up 'timings' values in ProfileResult ctor
                parser.text();
            } else if (NODE_TIME_RAW.match(currentFieldName)) {
                // skip, total time is calculate by adding up 'timings' values in ProfileResult ctor
                parser.longValue();
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else if (token == XContentParser.Token.START_OBJECT) {
            if (BREAKDOWN.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                    ensureExpectedToken(parser.currentToken(), XContentParser.Token.FIELD_NAME, parser::getTokenLocation);
                    String name = parser.currentName();
                    ensureExpectedToken(parser.nextToken(), XContentParser.Token.VALUE_NUMBER, parser::getTokenLocation);
                    long value = parser.longValue();
                    timings.put(name, value);
                }
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        } else if (token == XContentParser.Token.START_ARRAY) {
            if (CHILDREN.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    children.add(ProfileResult.fromXContent(parser));
                }
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        }
    }
    return new ProfileResult(type, description, timings, children);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
/**
 * Parses and returns the given item.
 */
public static Item parse(XContentParser parser, Item item) throws IOException {
    XContentParser.Token token;
    String currentFieldName = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (currentFieldName != null) {
            if (Field.INDEX.match(currentFieldName)) {
                item.index = parser.text();
            } else if (Field.TYPE.match(currentFieldName)) {
                item.type = parser.text();
            } else if (Field.ID.match(currentFieldName)) {
                item.id = parser.text();
            } else if (Field.DOC.match(currentFieldName)) {
                item.doc = jsonBuilder().copyCurrentStructure(parser).bytes();
                item.xContentType = XContentType.JSON;
            } else if (Field.FIELDS.match(currentFieldName)) {
                if (token == XContentParser.Token.START_ARRAY) {
                    List<String> fields = new ArrayList<>();
                    while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
                        fields.add(parser.text());
                    }
                    item.fields(fields.toArray(new String[fields.size()]));
                } else {
                    throw new ElasticsearchParseException(
                            "failed to parse More Like This item. field [fields] must be an array");
                }
            } else if (Field.PER_FIELD_ANALYZER.match(currentFieldName)) {
                item.perFieldAnalyzer(TermVectorsRequest.readPerFieldAnalyzer(parser.map()));
            } else if ("_routing".equals(currentFieldName) || "routing".equals(currentFieldName)) {
                item.routing = parser.text();
            } else if ("_version".equals(currentFieldName) || "version".equals(currentFieldName)) {
                item.version = parser.longValue();
            } else if ("_version_type".equals(currentFieldName) || "_versionType".equals(currentFieldName)
                    || "version_type".equals(currentFieldName) || "versionType".equals(currentFieldName)) {
                item.versionType = VersionType.fromString(parser.text());
            } else {
                throw new ElasticsearchParseException(
                        "failed to parse More Like This item. unknown field [{}]", currentFieldName);
            }
        }
    }
    if (item.id != null && item.doc != null) {
        throw new ElasticsearchParseException(
                "failed to parse More Like This item. either [id] or [doc] can be specified, but not both!");
    }
    if (item.id == null && item.doc == null) {
        throw new ElasticsearchParseException(
                "failed to parse More Like This item. neither [id] nor [doc] is specified!");
    }
    return item;
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
public static GetResult fromXContentEmbedded(XContentParser parser) throws IOException {
    XContentParser.Token token = parser.nextToken();
    ensureExpectedToken(XContentParser.Token.FIELD_NAME, token, parser::getTokenLocation);

    String currentFieldName = parser.currentName();
    String index = null, type = null, id = null;
    long version = -1;
    boolean found = false;
    BytesReference source = null;
    Map<String, GetField> fields = new HashMap<>();
    while((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (_INDEX.equals(currentFieldName)) {
                index = parser.text();
            } else if (_TYPE.equals(currentFieldName)) {
                type = parser.text();
            } else if (_ID.equals(currentFieldName)) {
                id = parser.text();
            }  else if (_VERSION.equals(currentFieldName)) {
                version = parser.longValue();
            } else if (FOUND.equals(currentFieldName)) {
                found = parser.booleanValue();
            } else {
                fields.put(currentFieldName, new GetField(currentFieldName, Collections.singletonList(parser.objectText())));
            }
        } else if (token == XContentParser.Token.START_OBJECT) {
            if (SourceFieldMapper.NAME.equals(currentFieldName)) {
                try (XContentBuilder builder = XContentBuilder.builder(parser.contentType().xContent())) {
                    //the original document gets slightly modified: whitespaces or pretty printing are not preserved,
                    //it all depends on the current builder settings
                    builder.copyCurrentStructure(parser);
                    source = builder.bytes();
                }
            } else if (FIELDS.equals(currentFieldName)) {
                while(parser.nextToken() != XContentParser.Token.END_OBJECT) {
                    GetField getField = GetField.fromXContent(parser);
                    fields.put(getField.getName(), getField);
                }
            } else {
                throwUnknownField(currentFieldName, parser.getTokenLocation());
            }
        }
    }
    return new GetResult(index, type, id, version, found, source, fields);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
/**
 * Parses shard snapshot metadata
 *
 * @param parser parser
 * @return shard snapshot metadata
 */
public static BlobStoreIndexShardSnapshot fromXContent(XContentParser parser) throws IOException {
    String snapshot = null;
    long indexVersion = -1;
    long startTime = 0;
    long time = 0;
    int numberOfFiles = 0;
    long totalSize = 0;

    List<FileInfo> indexFiles = new ArrayList<>();
    if (parser.currentToken() == null) { // fresh parser? move to the first token
        parser.nextToken();
    }
    XContentParser.Token token = parser.currentToken();
    if (token == XContentParser.Token.START_OBJECT) {
        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                String currentFieldName = parser.currentName();
                token = parser.nextToken();
                if (token.isValue()) {
                    if (PARSE_NAME.match(currentFieldName)) {
                        snapshot = parser.text();
                    } else if (PARSE_INDEX_VERSION.match(currentFieldName)) {
                        // The index-version is needed for backward compatibility with v 1.0
                        indexVersion = parser.longValue();
                    } else if (PARSE_START_TIME.match(currentFieldName)) {
                        startTime = parser.longValue();
                    } else if (PARSE_TIME.match(currentFieldName)) {
                        time = parser.longValue();
                    } else if (PARSE_NUMBER_OF_FILES.match(currentFieldName)) {
                        numberOfFiles = parser.intValue();
                    } else if (PARSE_TOTAL_SIZE.match(currentFieldName)) {
                        totalSize = parser.longValue();
                    } else {
                        throw new ElasticsearchParseException("unknown parameter [{}]", currentFieldName);
                    }
                } else if (token == XContentParser.Token.START_ARRAY) {
                    if (PARSE_FILES.match(currentFieldName)) {
                        while ((parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                            indexFiles.add(FileInfo.fromXContent(parser));
                        }
                    } else {
                        throw new ElasticsearchParseException("unknown parameter [{}]", currentFieldName);
                    }
                } else {
                    throw new ElasticsearchParseException("unexpected token  [{}]", token);
                }
            } else {
                throw new ElasticsearchParseException("unexpected token [{}]", token);
            }
        }
    }
    return new BlobStoreIndexShardSnapshot(snapshot, indexVersion, Collections.unmodifiableList(indexFiles),
                                           startTime, time, numberOfFiles, totalSize);
}
 

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
@Override
Long parse(XContentParser parser, boolean coerce) throws IOException {
    return parser.longValue(coerce);
}
 

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

import org.elasticsearch.common.xcontent.XContentParser; //导入方法依赖的package包/类
/**
 * populates a request object (pre-populated with defaults) based on a parser.
 */
public static void parseRequest(TermVectorsRequest termVectorsRequest, XContentParser parser) throws IOException {
    XContentParser.Token token;
    String currentFieldName = null;
    List<String> fields = new ArrayList<>();
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (currentFieldName != null) {
            if (currentFieldName.equals("fields")) {
                if (token == XContentParser.Token.START_ARRAY) {
                    while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
                        fields.add(parser.text());
                    }
                } else {
                    throw new ElasticsearchParseException("failed to parse term vectors request. field [fields] must be an array");
                }
            } else if (currentFieldName.equals("offsets")) {
                termVectorsRequest.offsets(parser.booleanValue());
            } else if (currentFieldName.equals("positions")) {
                termVectorsRequest.positions(parser.booleanValue());
            } else if (currentFieldName.equals("payloads")) {
                termVectorsRequest.payloads(parser.booleanValue());
            } else if (currentFieldName.equals("term_statistics") || currentFieldName.equals("termStatistics")) {
                termVectorsRequest.termStatistics(parser.booleanValue());
            } else if (currentFieldName.equals("field_statistics") || currentFieldName.equals("fieldStatistics")) {
                termVectorsRequest.fieldStatistics(parser.booleanValue());
            } else if (currentFieldName.equals("dfs")) {
                throw new IllegalArgumentException("distributed frequencies is not supported anymore for term vectors");
            } else if (currentFieldName.equals("per_field_analyzer") || currentFieldName.equals("perFieldAnalyzer")) {
                termVectorsRequest.perFieldAnalyzer(readPerFieldAnalyzer(parser.map()));
            } else if (currentFieldName.equals("filter")) {
                termVectorsRequest.filterSettings(readFilterSettings(parser));
            } else if ("_index".equals(currentFieldName)) { // the following is important for multi request parsing.
                termVectorsRequest.index = parser.text();
            } else if ("_type".equals(currentFieldName)) {
                termVectorsRequest.type = parser.text();
            } else if ("_id".equals(currentFieldName)) {
                if (termVectorsRequest.doc != null) {
                    throw new ElasticsearchParseException("failed to parse term vectors request. either [id] or [doc] can be specified, but not both!");
                }
                termVectorsRequest.id = parser.text();
            } else if ("doc".equals(currentFieldName)) {
                if (termVectorsRequest.id != null) {
                    throw new ElasticsearchParseException("failed to parse term vectors request. either [id] or [doc] can be specified, but not both!");
                }
                termVectorsRequest.doc(jsonBuilder().copyCurrentStructure(parser));
            } else if ("_routing".equals(currentFieldName) || "routing".equals(currentFieldName)) {
                termVectorsRequest.routing = parser.text();
            } else if ("_parent".equals(currentFieldName) || "parent".equals(currentFieldName)) {
                termVectorsRequest.parent = parser.text();
            } else if ("_version".equals(currentFieldName) || "version".equals(currentFieldName)) {
                termVectorsRequest.version = parser.longValue();
            } else if ("_version_type".equals(currentFieldName) || "_versionType".equals(currentFieldName) || "version_type".equals(currentFieldName) || "versionType".equals(currentFieldName)) {
                termVectorsRequest.versionType = VersionType.fromString(parser.text());
            } else {
                throw new ElasticsearchParseException("failed to parse term vectors request. unknown field [{}]", currentFieldName);
            }
        }
    }
    if (fields.size() > 0) {
        String[] fieldsAsArray = new String[fields.size()];
        termVectorsRequest.selectedFields(fields.toArray(fieldsAsArray));
    }
}