1. 包列表
  2. 类列表
  3. org.elasticsearch.common.xcontent.XContentBuilder

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

项目：Elasticsearch    文件：InternalHistogram.java    
@Override
public XContentBuilder doXContentBody(XContentBuilder builder, Params params) throws IOException {
    if (keyed) {
        builder.startObject(CommonFields.BUCKETS);
    } else {
        builder.startArray(CommonFields.BUCKETS);
    }
    for (B bucket : buckets) {
        bucket.toXContent(builder, params);
    }
    if (keyed) {
        builder.endObject();
    } else {
        builder.endArray();
    }
    return builder;
}
项目：elasticsearch_my    文件：AnalyzeResponse.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject();
    if (tokens != null) {
        builder.startArray(Fields.TOKENS);
        for (AnalyzeToken token : tokens) {
            token.toXContent(builder, params);
        }
        builder.endArray();
    }

    if (detail != null) {
        builder.startObject(Fields.DETAIL);
        detail.toXContent(builder, params);
        builder.endObject();
    }
    builder.endObject();
    return builder;
}
项目：elasticsearch_my    文件：MultiFieldCopyToMapperTests.java    
private static XContentBuilder createMappinmgWithCopyToInMultiField() throws IOException {
    XContentBuilder mapping = jsonBuilder();
    mapping.startObject()
        .startObject("type")
        .startObject("properties")
        .startObject("a")
        .field("type", "text")
        .endObject()
        .startObject("b")
        .field("type", "text")
        .startObject("fields")
        .startObject("c")
        .field("type", "text")
        .field("copy_to", "a")
        .endObject()
        .endObject()
        .endObject()
        .endObject()
        .endObject()
        .endObject();
    return mapping;
}
项目：Elasticsearch    文件：SamplerAggregationBuilder.java    
@Override
protected XContentBuilder doInternalXContent(XContentBuilder builder, Params params) throws IOException {
    // builder.startObject();
    if (shardSize != SamplerParser.DEFAULT_SHARD_SAMPLE_SIZE) {
        builder.field(SamplerParser.SHARD_SIZE_FIELD.getPreferredName(), shardSize);
    }

    if (maxDocsPerValue != SamplerParser.MAX_DOCS_PER_VALUE_DEFAULT) {
        builder.field(SamplerParser.MAX_DOCS_PER_VALUE_FIELD.getPreferredName(), maxDocsPerValue);
    }
    if (executionHint != null) {
        builder.field(SamplerParser.EXECUTION_HINT_FIELD.getPreferredName(), executionHint);
    }

    return builder;
}
项目：Elasticsearch    文件：ShardStats.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject(Fields.ROUTING)
            .field(Fields.STATE, shardRouting.state())
            .field(Fields.PRIMARY, shardRouting.primary())
            .field(Fields.NODE, shardRouting.currentNodeId())
            .field(Fields.RELOCATING_NODE, shardRouting.relocatingNodeId())
            .endObject();

    commonStats.toXContent(builder, params);
    if (commitStats != null) {
        commitStats.toXContent(builder, params);
    }
    builder.startObject(Fields.SHARD_PATH);
    builder.field(Fields.STATE_PATH, statePath);
    builder.field(Fields.DATA_PATH, dataPath);
    builder.field(Fields.IS_CUSTOM_DATA_PATH, isCustomDataPath);
    builder.endObject();
    return builder;
}
项目：elasticsearch_my    文件：RangeFieldMapperTests.java    
public void testSerializeDefaults() throws Exception {
    for (String type : TYPES) {
        String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", type).endObject().endObject()
            .endObject().endObject().string();

        DocumentMapper docMapper = parser.parse("type", new CompressedXContent(mapping));
        RangeFieldMapper mapper = (RangeFieldMapper) docMapper.root().getMapper("field");
        XContentBuilder builder = XContentFactory.jsonBuilder().startObject();
        mapper.doXContentBody(builder, true, ToXContent.EMPTY_PARAMS);
        String got = builder.endObject().string();

        // if type is date_range we check that the mapper contains the default format and locale
        // otherwise it should not contain a locale or format
        assertTrue(got, got.contains("\"format\":\"strict_date_optional_time||epoch_millis\"") == type.equals("date_range"));
        assertTrue(got, got.contains("\"locale\":" + "\"" + Locale.ROOT + "\"") == type.equals("date_range"));
    }
}
项目：Elasticsearch    文件：IndexingStats.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
    builder.startObject(Fields.INDEXING);
    totalStats.toXContent(builder, params);
    if (typeStats != null && !typeStats.isEmpty()) {
        builder.startObject(Fields.TYPES);
        for (Map.Entry<String, Stats> entry : typeStats.entrySet()) {
            builder.startObject(entry.getKey(), XContentBuilder.FieldCaseConversion.NONE);
            entry.getValue().toXContent(builder, params);
            builder.endObject();
        }
        builder.endObject();
    }
    builder.endObject();
    return builder;
}
项目：elasticsearch_my    文件：MainResponse.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject();
    builder.field("name", nodeName);
    builder.field("cluster_name", clusterName.value());
    builder.field("cluster_uuid", clusterUuid);
    builder.startObject("version")
        .field("number", version.toString())
        .field("build_hash", build.shortHash())
        .field("build_date", build.date())
        .field("build_snapshot", build.isSnapshot())
        .field("lucene_version", version.luceneVersion.toString())
        .endObject();
    builder.field("tagline", "You Know, for Search");
    builder.endObject();
    return builder;
}
项目：elasticsearch_my    文件：AggregatorFactoriesTests.java    
public void testTwoAggs() throws Exception {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    XContentBuilder source = JsonXContent.contentBuilder()
            .startObject()
                .startObject("by_date")
                    .startObject("date_histogram")
                        .field("field", "timestamp")
                        .field("interval", "month")
                    .endObject()
                    .startObject("aggs")
                        .startObject("tag_count")
                            .startObject("cardinality")
                                .field("field", "tag")
                            .endObject()
                        .endObject()
                    .endObject()
                    .startObject("aggs") // 2nd "aggs": illegal
                        .startObject("tag_count2")
                            .startObject("cardinality")
                                .field("field", "tag")
                            .endObject()
                        .endObject()
                    .endObject()
                .endObject()
            .endObject();
    XContentParser parser = createParser(source);
    QueryParseContext parseContext = new QueryParseContext(parser);
    assertSame(XContentParser.Token.START_OBJECT, parser.nextToken());
    Exception e = expectThrows(ParsingException.class, () -> AggregatorFactories.parseAggregators(parseContext));
    assertThat(e.toString(), containsString("Found two sub aggregation definitions under [by_date]"));
}
项目：elasticsearch_my    文件：MultiTermVectorsResponse.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject();
    builder.startArray(Fields.DOCS);
    for (MultiTermVectorsItemResponse response : responses) {
        if (response.isFailed()) {
            builder.startObject();
            Failure failure = response.getFailure();
            builder.field(Fields._INDEX, failure.getIndex());
            builder.field(Fields._TYPE, failure.getType());
            builder.field(Fields._ID, failure.getId());
            ElasticsearchException.generateFailureXContent(builder, params, failure.getCause(), true);
            builder.endObject();
        } else {
            TermVectorsResponse getResponse = response.getResponse();
            getResponse.toXContent(builder, params);
        }
    }
    builder.endArray();
    builder.endObject();
    return builder;
}
项目：Elasticsearch    文件：PointCollection.java    
/**
 * builds an array of coordinates to a {@link XContentBuilder}
 * 
 * @param builder builder to use 
 * @param closed repeat the first point at the end of the array if it's not already defines as last element of the array  
 * @return the builder
 */
protected XContentBuilder coordinatesToXcontent(XContentBuilder builder, boolean closed) throws IOException {
    builder.startArray();
    for(Coordinate point : points) {
        toXContent(builder, point);
    }
    if(closed) {
        Coordinate start = points.get(0);
        Coordinate end = points.get(points.size()-1);
        if(start.x != end.x || start.y != end.y) {
            toXContent(builder, points.get(0));
        }
    }
    builder.endArray();
    return builder;
}
项目：gchange-pod    文件：CitiesLocationDaoImpl.java    
public XContentBuilder createIndexMapping() {

        try {
            XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject(CITY_TYPE)
                    .startObject("properties")

                    // city
                    .startObject("name")
                    .field("type", "string")
                    .endObject()

                    // country
                    .startObject("country")
                    .field("type", "string")
                    .field("index", "not_analyzed")
                    .endObject()

                    .endObject()
                    .endObject().endObject();

            return mapping;
        }
        catch(IOException ioe) {
            throw new TechnicalException(String.format("Error while getting mapping for index [%s/%s]: %s", INDEX, CITY_TYPE, ioe.getMessage()), ioe);
        }
    }
项目：elasticsearch_my    文件：RestReindexActionTests.java    
public void testPipelineQueryParameterIsError() throws IOException {
    RestReindexAction action = new RestReindexAction(Settings.EMPTY, mock(RestController.class));

    FakeRestRequest.Builder request = new FakeRestRequest.Builder(xContentRegistry());
    try (XContentBuilder body = JsonXContent.contentBuilder().prettyPrint()) {
        body.startObject(); {
            body.startObject("source"); {
                body.field("index", "source");
            }
            body.endObject();
            body.startObject("dest"); {
                body.field("index", "dest");
            }
            body.endObject();
        }
        body.endObject();
        request.withContent(body.bytes(), body.contentType());
    }
    request.withParams(singletonMap("pipeline", "doesn't matter"));
    Exception e = expectThrows(IllegalArgumentException.class, () -> action.buildRequest(request.build()));

    assertEquals("_reindex doesn't support [pipeline] as a query parmaeter. Specify it in the [dest] object instead.", e.getMessage());
}
项目：elasticsearch_my    文件：RestForceMergeAction.java    
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    ForceMergeRequest mergeRequest = new ForceMergeRequest(Strings.splitStringByCommaToArray(request.param("index")));
    mergeRequest.indicesOptions(IndicesOptions.fromRequest(request, mergeRequest.indicesOptions()));
    mergeRequest.maxNumSegments(request.paramAsInt("max_num_segments", mergeRequest.maxNumSegments()));
    mergeRequest.onlyExpungeDeletes(request.paramAsBoolean("only_expunge_deletes", mergeRequest.onlyExpungeDeletes()));
    mergeRequest.flush(request.paramAsBoolean("flush", mergeRequest.flush()));
    return channel -> client.admin().indices().forceMerge(mergeRequest, new RestBuilderListener<ForceMergeResponse>(channel) {
        @Override
        public RestResponse buildResponse(ForceMergeResponse response, XContentBuilder builder) throws Exception {
            builder.startObject();
            buildBroadcastShardsHeader(builder, request, response);
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });
}
项目：elasticsearch_my    文件：RolloverRequestTests.java    
public void testConditionsParsing() throws Exception {
    final RolloverRequest request = new RolloverRequest(randomAsciiOfLength(10), randomAsciiOfLength(10));
    final XContentBuilder builder = XContentFactory.jsonBuilder()
        .startObject()
            .startObject("conditions")
                .field("max_age", "10d")
                .field("max_docs", 100)
            .endObject()
        .endObject();
    RolloverRequest.PARSER.parse(createParser(builder), request, null);
    Set<Condition> conditions = request.getConditions();
    assertThat(conditions.size(), equalTo(2));
    for (Condition condition : conditions) {
        if (condition instanceof MaxAgeCondition) {
            MaxAgeCondition maxAgeCondition = (MaxAgeCondition) condition;
            assertThat(maxAgeCondition.value.getMillis(), equalTo(TimeValue.timeValueHours(24 * 10).getMillis()));
        } else if (condition instanceof MaxDocsCondition) {
            MaxDocsCondition maxDocsCondition = (MaxDocsCondition) condition;
            assertThat(maxDocsCondition.value, equalTo(100L));
        } else {
            fail("unexpected condition " + condition);
        }
    }
}
项目：elasticsearch_my    文件：MultiFieldTests.java    
public void testMultiFieldWithDot() throws IOException {
    XContentBuilder mapping = jsonBuilder();
    mapping.startObject()
            .startObject("my_type")
            .startObject("properties")
            .startObject("city")
            .field("type", "text")
            .startObject("fields")
            .startObject("raw.foo")
            .field("type", "text")
            .field("index", "not_analyzed")
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .endObject();

    MapperService mapperService = createIndex("test").mapperService();
    try {
        mapperService.documentMapperParser().parse("my_type", new CompressedXContent(mapping.string()));
        fail("this should throw an exception because one field contains a dot");
    } catch (MapperParsingException e) {
        assertThat(e.getMessage(), equalTo("Field name [raw.foo] which is a multi field of [city] cannot contain '.'"));
    }
}
项目：Elasticsearch    文件：PipelineAggregatorBuilder.java    
@Override
public final XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject(getName());

    if (this.metaData != null) {
        builder.field("meta", this.metaData);
    }
    builder.startObject(type);

    if (bucketsPaths != null) {
        builder.startArray(PipelineAggregator.Parser.BUCKETS_PATH.getPreferredName());
        for (String path : bucketsPaths) {
            builder.value(path);
        }
        builder.endArray();
    }

    internalXContent(builder, params);

    builder.endObject();

    return builder.endObject();
}
项目：elasticsearch_my    文件：GeoShapeQueryTests.java    
public void testContainsShapeQuery() throws Exception {
    // Create a random geometry collection.
    Rectangle mbr = xRandomRectangle(random(), xRandomPoint(random()), true);
    GeometryCollectionBuilder gcb = createGeometryCollectionWithin(random(), mbr);

    client().admin().indices().prepareCreate("test").addMapping("type", "location", "type=geo_shape,tree=quadtree" )
            .execute().actionGet();

    XContentBuilder docSource = gcb.toXContent(jsonBuilder().startObject().field("location"), null).endObject();
    client().prepareIndex("test", "type", "1").setSource(docSource).setRefreshPolicy(IMMEDIATE).get();

    // index the mbr of the collection
    EnvelopeBuilder env = new EnvelopeBuilder(new Coordinate(mbr.getMinX(), mbr.getMaxY()), new Coordinate(mbr.getMaxX(), mbr.getMinY()));
    docSource = env.toXContent(jsonBuilder().startObject().field("location"), null).endObject();
    client().prepareIndex("test", "type", "2").setSource(docSource).setRefreshPolicy(IMMEDIATE).get();

    ShapeBuilder filterShape = (gcb.getShapeAt(randomIntBetween(0, gcb.numShapes() - 1)));
    GeoShapeQueryBuilder filter = QueryBuilders.geoShapeQuery("location", filterShape)
            .relation(ShapeRelation.CONTAINS);
    SearchResponse response = client().prepareSearch("test").setTypes("type").setQuery(QueryBuilders.matchAllQuery())
            .setPostFilter(filter).get();
    assertSearchResponse(response);

    assertThat(response.getHits().getTotalHits(), greaterThan(0L));
}
项目：elasticsearch_my    文件：GeoPointFieldMapperTests.java    
public void testLatLonInOneValueArray() throws Exception {
    XContentBuilder xContentBuilder = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("properties").startObject("point").field("type", "geo_point").field("doc_values", false);
    String mapping = xContentBuilder.field("store", true).endObject().endObject().endObject().endObject().string();
    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type",
        new CompressedXContent(mapping));

    ParsedDocument doc = defaultMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .startArray("point")
            .value("1.2,1.3")
            .value("1.4,1.5")
            .endArray()
            .endObject()
            .bytes());

    // doc values are enabled by default, but in this test we disable them; we should only have 2 points
    assertThat(doc.rootDoc().getFields("point"), notNullValue());
    assertThat(doc.rootDoc().getFields("point").length, equalTo(4));
}
项目：Elasticsearch    文件：TransportInfo.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject(Fields.TRANSPORT);
    builder.array(Fields.BOUND_ADDRESS, (Object[]) address.boundAddresses());
    builder.field(Fields.PUBLISH_ADDRESS, address.publishAddress().toString());
    builder.startObject(Fields.PROFILES);
    if (profileAddresses != null && profileAddresses.size() > 0) {
        for (Map.Entry<String, BoundTransportAddress> entry : profileAddresses.entrySet()) {
            builder.startObject(entry.getKey());
            builder.array(Fields.BOUND_ADDRESS, (Object[]) entry.getValue().boundAddresses());
            builder.field(Fields.PUBLISH_ADDRESS, entry.getValue().publishAddress().toString());
            builder.endObject();
        }
    }
    builder.endObject();
    builder.endObject();
    return builder;
}
项目：elasticsearch_my    文件：ElasticsearchExceptionTests.java    
public void testFromXContent() throws IOException {
    final XContent xContent = randomFrom(XContentType.values()).xContent();
    XContentBuilder builder = XContentBuilder.builder(xContent)
                                                .startObject()
                                                    .field("type", "foo")
                                                    .field("reason", "something went wrong")
                                                    .field("stack_trace", "...")
                                                .endObject();

    ElasticsearchException parsed;
    try (XContentParser parser = createParser(xContent, builder.bytes())) {
        assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
        parsed = ElasticsearchException.fromXContent(parser);
        assertEquals(XContentParser.Token.END_OBJECT, parser.currentToken());
        assertNull(parser.nextToken());
    }

    assertNotNull(parsed);
    assertEquals(parsed.getMessage(), "Elasticsearch exception [type=foo, reason=something went wrong, stack_trace=...]");
}
项目：Elasticsearch    文件：ShardRouting.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject()
        .field("state", state())
        .field("primary", primary())
        .field("node", currentNodeId())
        .field("relocating_node", relocatingNodeId())
        .field("shard", shardId().id())
        .field("index", shardId().index().name())
        .field("version", version);
    if (expectedShardSize != UNAVAILABLE_EXPECTED_SHARD_SIZE) {
        builder.field("expected_shard_size_in_bytes", expectedShardSize);
    }
    if (restoreSource() != null) {
        builder.field("restore_source");
        restoreSource().toXContent(builder, params);
    }
    if (allocationId != null) {
        allocationId.toXContent(builder, params);
    }
    if (unassignedInfo != null) {
        unassignedInfo.toXContent(builder, params);
    }
    return builder.endObject();
}
项目：Elasticsearch    文件：ElasticsearchException.java    
/**
 * Statis toXContent helper method that also renders non {@link org.elasticsearch.ElasticsearchException} instances as XContent.
 */
public static void toXContent(XContentBuilder builder, Params params, Throwable ex) throws IOException {
    ex = ExceptionsHelper.unwrapCause(ex);
    if (ex instanceof ElasticsearchException) {
        ((ElasticsearchException) ex).toXContent(builder, params);
    } else {
        builder.field("type", getExceptionName(ex));
        builder.field("reason", ex.getMessage());
        if (ex.getCause() != null) {
            builder.field("caused_by");
            builder.startObject();
            toXContent(builder, params, ex.getCause());
            builder.endObject();
        }
        if (params.paramAsBoolean(REST_EXCEPTION_SKIP_STACK_TRACE, REST_EXCEPTION_SKIP_STACK_TRACE_DEFAULT) == false) {
            builder.field("stack_trace", ExceptionsHelper.stackTrace(ex));
        }
    }
}
项目：Elasticsearch    文件：RestDeleteIndexedScriptAction.java    
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, Client client) {
    DeleteIndexedScriptRequest deleteIndexedScriptRequest = new DeleteIndexedScriptRequest(getScriptLang(request), request.param("id"));
    deleteIndexedScriptRequest.version(request.paramAsLong("version", deleteIndexedScriptRequest.version()));
    deleteIndexedScriptRequest.versionType(VersionType.fromString(request.param("version_type"), deleteIndexedScriptRequest.versionType()));
    client.deleteIndexedScript(deleteIndexedScriptRequest, new RestBuilderListener<DeleteIndexedScriptResponse>(channel) {
        @Override
        public RestResponse buildResponse(DeleteIndexedScriptResponse result, XContentBuilder builder) throws Exception {
            builder.startObject()
                    .field(Fields.FOUND, result.isFound())
                    .field(Fields._INDEX, result.getIndex())
                    .field(Fields._TYPE, result.getType())
                    .field(Fields._ID, result.getId())
                    .field(Fields._VERSION, result.getVersion())
                    .endObject();
            RestStatus status = OK;
            if (!result.isFound()) {
                status = NOT_FOUND;
            }
            return new BytesRestResponse(status, builder);
        }
    });
}
项目：elasticsearch_my    文件：Setting.java    
private static String arrayToParsableString(String[] array) {
    try {
        XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent());
        builder.startArray();
        for (String element : array) {
            builder.value(element);
        }
        builder.endArray();
        return builder.string();
    } catch (IOException ex) {
        throw new ElasticsearchException(ex);
    }
}
项目：elasticsearch_my    文件：MultiFieldCopyToMapperTests.java    
public void testExceptionForCopyToInMultiFields() throws IOException {
    XContentBuilder mapping = createMappinmgWithCopyToInMultiField();

    // first check that for newer versions we throw exception if copy_to is found withing multi field
    MapperService mapperService = MapperTestUtils.newMapperService(xContentRegistry(), createTempDir(), Settings.EMPTY);
    try {
        mapperService.parse("type", new CompressedXContent(mapping.string()), true);
        fail("Parsing should throw an exception because the mapping contains a copy_to in a multi field");
    } catch (MapperParsingException e) {
        assertThat(e.getMessage(), equalTo("copy_to in multi fields is not allowed. Found the copy_to in field [c] which is within a multi field."));
    }
}
项目：incubator-sdap-mudrod    文件：LinkageTriple.java    
public static void addMapping(ESDriver es, String index, String type) {
  XContentBuilder Mapping;
  try {
    Mapping = jsonBuilder().startObject().startObject(type).startObject("properties").startObject("concept_A").field("type", "string").field("index", "not_analyzed").endObject()
        .startObject("concept_B").field("type", "string").field("index", "not_analyzed").endObject()

        .endObject().endObject().endObject();

    es.getClient().admin().indices().preparePutMapping(index).setType(type).setSource(Mapping).execute().actionGet();
  } catch (IOException e) {
    e.printStackTrace();
  }
}
项目：elasticsearch_my    文件：ClusterHealthResponse.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject();
    builder.field(CLUSTER_NAME, getClusterName());
    builder.field(STATUS, getStatus().name().toLowerCase(Locale.ROOT));
    builder.field(TIMED_OUT, isTimedOut());
    builder.field(NUMBER_OF_NODES, getNumberOfNodes());
    builder.field(NUMBER_OF_DATA_NODES, getNumberOfDataNodes());
    builder.field(ACTIVE_PRIMARY_SHARDS, getActivePrimaryShards());
    builder.field(ACTIVE_SHARDS, getActiveShards());
    builder.field(RELOCATING_SHARDS, getRelocatingShards());
    builder.field(INITIALIZING_SHARDS, getInitializingShards());
    builder.field(UNASSIGNED_SHARDS, getUnassignedShards());
    builder.field(DELAYED_UNASSIGNED_SHARDS, getDelayedUnassignedShards());
    builder.field(NUMBER_OF_PENDING_TASKS, getNumberOfPendingTasks());
    builder.field(NUMBER_OF_IN_FLIGHT_FETCH, getNumberOfInFlightFetch());
    builder.timeValueField(TASK_MAX_WAIT_TIME_IN_QUEUE_IN_MILLIS, TASK_MAX_WAIT_TIME_IN_QUEUE, getTaskMaxWaitingTime());
    builder.percentageField(ACTIVE_SHARDS_PERCENT_AS_NUMBER, ACTIVE_SHARDS_PERCENT, getActiveShardsPercent());

    String level = params.param("level", "cluster");
    boolean outputIndices = "indices".equals(level) || "shards".equals(level);

    if (outputIndices) {
        builder.startObject(INDICES);
        for (ClusterIndexHealth indexHealth : clusterStateHealth.getIndices().values()) {
            builder.startObject(indexHealth.getIndex());
            indexHealth.toXContent(builder, params);
            builder.endObject();
        }
        builder.endObject();
    }
    builder.endObject();
    return builder;
}
项目：memory-graph    文件：MemgraphQueryStringQueryBuilder.java    
@Override
protected void doXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
    builder.startObject("memgraph_query_string");
    super.doXContent(builder, params);

    builder.startArray("authorizations");
    for (String authorization : authorizations.getAuthorizations()) {
        builder.value(authorization);
    }
    builder.endArray();

    builder.endObject();
}
项目：Elasticsearch    文件：DerivativeBuilder.java    
@Override
protected XContentBuilder internalXContent(XContentBuilder builder, Params params) throws IOException {
    if (format != null) {
        builder.field(DerivativeParser.FORMAT.getPreferredName(), format);
    }
    if (gapPolicy != null) {
        builder.field(DerivativeParser.GAP_POLICY.getPreferredName(), gapPolicy.getName());
    }
    if (unit != null) {
        builder.field(DerivativeParser.UNIT.getPreferredName(), unit);
    }
    return builder;
}
项目：elasticsearch_my    文件：ThreadPoolSerializationTests.java    
public void testThatToXContentWritesOutUnboundedCorrectly() throws Exception {
    ThreadPool.Info info = new ThreadPool.Info("foo", threadPoolType, 1, 10, TimeValue.timeValueMillis(3000), null);
    XContentBuilder builder = jsonBuilder();
    builder.startObject();
    info.toXContent(builder, ToXContent.EMPTY_PARAMS);
    builder.endObject();

    Map<String, Object> map = XContentHelper.convertToMap(builder.bytes(), false, builder.contentType()).v2();
    assertThat(map, hasKey("foo"));
    map = (Map<String, Object>) map.get("foo");
    assertThat(map, hasKey("queue_size"));
    assertThat(map.get("queue_size").toString(), is("-1"));
}
项目：Elasticsearch    文件：Strings.java    
/**
 * Return a {@link String} that is the json representation of the provided
 * {@link ToXContent}.
 */
public static String toString(ToXContent toXContent) {
    try {
        XContentBuilder builder = JsonXContent.contentBuilder();
        toXContent.toXContent(builder, ToXContent.EMPTY_PARAMS);
        return builder.string();
    } catch (IOException e) {
        throw new AssertionError("Cannot happen", e);
    }
}
项目：Elasticsearch    文件：MultiPolygonBuilder.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject();
    builder.field(FIELD_TYPE, TYPE.shapename);
    builder.startArray(FIELD_COORDINATES);
    for(BasePolygonBuilder<?> polygon : polygons) {
        builder.startArray();
        polygon.coordinatesArray(builder, params);
        builder.endArray();
    }
    builder.endArray();
    return builder.endObject();
}
项目：elasticsearch_my    文件：SnapshotShardsStats.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
    builder.startObject(Fields.SHARDS_STATS);
    builder.field(Fields.INITIALIZING, getInitializingShards());
    builder.field(Fields.STARTED, getStartedShards());
    builder.field(Fields.FINALIZING, getFinalizingShards());
    builder.field(Fields.DONE, getDoneShards());
    builder.field(Fields.FAILED, getFailedShards());
    builder.field(Fields.TOTAL, getTotalShards());
    builder.endObject();
    return builder;
}
项目：Elasticsearch    文件：RestoreSource.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    return builder.startObject()
            .field("repository", snapshotId.getRepository())
            .field("snapshot", snapshotId.getSnapshot())
            .field("version", version.toString())
            .field("index", index)
            .endObject();
}
项目：elasticsearch_my    文件：ClusterStatsNodes.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject(Fields.CPU).field(Fields.PERCENT, cpuPercent).endObject();
    if (count > 0) {
        builder.startObject(Fields.OPEN_FILE_DESCRIPTORS);
        builder.field(Fields.MIN, getMinOpenFileDescriptors());
        builder.field(Fields.MAX, getMaxOpenFileDescriptors());
        builder.field(Fields.AVG, getAvgOpenFileDescriptors());
        builder.endObject();
    }
    return builder;
}
项目：Elasticsearch    文件：StoreStats.java    
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    builder.startObject(Fields.STORE);
    builder.byteSizeField(Fields.SIZE_IN_BYTES, Fields.SIZE, sizeInBytes);
    builder.timeValueField(Fields.THROTTLE_TIME_IN_MILLIS, Fields.THROTTLE_TIME, throttleTime());
    builder.endObject();
    return builder;
}
项目：elasticsearch_my    文件：ScoreFunctionBuilder.java    
@Override
public final XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
    if (weight != null) {
        builder.field(FunctionScoreQueryBuilder.WEIGHT_FIELD.getPreferredName(), weight);
    }
    doXContent(builder, params);
    return builder;
}
项目：elasticsearch_my    文件：IndexShardTests.java    
public void testShardStats() throws IOException {

        IndexShard shard = newStartedShard();
        ShardStats stats = new ShardStats(shard.routingEntry(), shard.shardPath(),
            new CommonStats(new IndicesQueryCache(Settings.EMPTY), shard, new CommonStatsFlags()), shard.commitStats(), shard.seqNoStats());
        assertEquals(shard.shardPath().getRootDataPath().toString(), stats.getDataPath());
        assertEquals(shard.shardPath().getRootStatePath().toString(), stats.getStatePath());
        assertEquals(shard.shardPath().isCustomDataPath(), stats.isCustomDataPath());

        if (randomBoolean() || true) { // try to serialize it to ensure values survive the serialization
            BytesStreamOutput out = new BytesStreamOutput();
            stats.writeTo(out);
            StreamInput in = out.bytes().streamInput();
            stats = ShardStats.readShardStats(in);
        }
        XContentBuilder builder = jsonBuilder();
        builder.startObject();
        stats.toXContent(builder, EMPTY_PARAMS);
        builder.endObject();
        String xContent = builder.string();
        StringBuilder expectedSubSequence = new StringBuilder("\"shard_path\":{\"state_path\":\"");
        expectedSubSequence.append(shard.shardPath().getRootStatePath().toString());
        expectedSubSequence.append("\",\"data_path\":\"");
        expectedSubSequence.append(shard.shardPath().getRootDataPath().toString());
        expectedSubSequence.append("\",\"is_custom_data_path\":").append(shard.shardPath().isCustomDataPath()).append("}");
        if (Constants.WINDOWS) {
            // Some path weirdness on windows
        } else {
            assertTrue(xContent.contains(expectedSubSequence));
        }
        closeShards(shard);
    }
项目：elasticsearch_my    文件：ContextCompletionSuggestSearchIT.java    
public void testContextFuzzy() throws Exception {
    LinkedHashMap<String, ContextMapping> map = new LinkedHashMap<>();
    map.put("cat", ContextBuilder.category("cat").field("cat").build());
    boolean addAnotherContext = randomBoolean();
    if (addAnotherContext) {
        map.put("type", ContextBuilder.category("type").field("type").build());
    }
    final CompletionMappingBuilder mapping = new CompletionMappingBuilder().context(map);
    createIndexAndMapping(mapping);
    int numDocs = 10;
    List<IndexRequestBuilder> indexRequestBuilders = new ArrayList<>();
    for (int i = 0; i < numDocs; i++) {
        XContentBuilder source = jsonBuilder()
                .startObject()
                .startObject(FIELD)
                .field("input", "sugxgestion" + i)
                .field("weight", i + 1)
                .endObject()
                .field("cat", "cat" + i % 2);
        if (addAnotherContext) {
            source.field("type", "type" + i % 3);
        }
        source.endObject();
        indexRequestBuilders.add(client().prepareIndex(INDEX, TYPE, "" + i)
                .setSource(source));
    }
    indexRandom(true, indexRequestBuilders);
    CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg", Fuzziness.ONE);
    assertSuggestions("foo", prefix, "sugxgestion9", "sugxgestion8", "sugxgestion7", "sugxgestion6", "sugxgestion5");
}