Java Strings.commaDelimitedListToStringArray方法代码示例

import org.elasticsearch.common.Strings; //导入方法依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    BulkRequest bulkRequest = Requests.bulkRequest();
    String defaultIndex = request.param("index");
    String defaultType = request.param("type");
    String defaultRouting = request.param("routing");
    String fieldsParam = request.param("fields");
    String defaultPipeline = request.param("pipeline");
    String[] defaultFields = fieldsParam != null ? Strings.commaDelimitedListToStringArray(fieldsParam) : null;

    String waitForActiveShards = request.param("wait_for_active_shards");
    if (waitForActiveShards != null) {
        bulkRequest.waitForActiveShards(ActiveShardCount.parseString(waitForActiveShards));
    }
    bulkRequest.timeout(request.paramAsTime("timeout", BulkShardRequest.DEFAULT_TIMEOUT));
    bulkRequest.setRefreshPolicy(request.param("refresh"));
    bulkRequest.add(request.content(), defaultIndex, defaultType, defaultRouting, defaultFields, null, defaultPipeline, null, true,
        request.getXContentType());

    // short circuit the call to the transport layer
    return channel -> {
        BulkRestBuilderListener listener = new BulkRestBuilderListener(channel, request);
        listener.onResponse(bulkRequest);
    };
}
 

import org.elasticsearch.common.Strings; //导入方法依赖的package包/类
public static void addFieldStringsFromParameter(TermVectorsRequest termVectorsRequest, String fields) {
    Set<String> selectedFields = termVectorsRequest.selectedFields();
    if (fields != null) {
        String[] paramFieldStrings = Strings.commaDelimitedListToStringArray(fields);
        for (String field : paramFieldStrings) {
            if (selectedFields == null) {
                selectedFields = new HashSet<>();
            }
            if (!selectedFields.contains(field)) {
                field = field.replaceAll("\\s", "");
                selectedFields.add(field);
            }
        }
    }
    if (selectedFields != null) {
        termVectorsRequest.selectedFields(selectedFields.toArray(new String[selectedFields.size()]));
    }
}
 

import org.elasticsearch.common.Strings; //导入方法依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    BulkRequest bulkRequest = Requests.bulkRequest();
    String defaultIndex = request.param("index");
    String defaultType = request.param("type");
    String defaultRouting = request.param("routing");
    FetchSourceContext defaultFetchSourceContext = FetchSourceContext.parseFromRestRequest(request);
    String fieldsParam = request.param("fields");
    if (fieldsParam != null) {
        DEPRECATION_LOGGER.deprecated("Deprecated field [fields] used, expected [_source] instead");
    }
    String[] defaultFields = fieldsParam != null ? Strings.commaDelimitedListToStringArray(fieldsParam) : null;
    String defaultPipeline = request.param("pipeline");
    String waitForActiveShards = request.param("wait_for_active_shards");
    if (waitForActiveShards != null) {
        bulkRequest.waitForActiveShards(ActiveShardCount.parseString(waitForActiveShards));
    }
    bulkRequest.timeout(request.paramAsTime("timeout", BulkShardRequest.DEFAULT_TIMEOUT));
    bulkRequest.setRefreshPolicy(request.param("refresh"));
    bulkRequest.add(request.content(), defaultIndex, defaultType, defaultRouting, defaultFields,
        defaultFetchSourceContext, defaultPipeline, null, allowExplicitIndex, request.getXContentType());

    return channel -> client.bulk(bulkRequest, new RestStatusToXContentListener<>(channel));
}
 

import org.elasticsearch.common.Strings; //导入方法依赖的package包/类
static public void addFieldStringsFromParameter(TermVectorsRequest termVectorsRequest, String fields) {
    Set<String> selectedFields = termVectorsRequest.selectedFields();
    if (fields != null) {
        String[] paramFieldStrings = Strings.commaDelimitedListToStringArray(fields);
        for (String field : paramFieldStrings) {
            if (selectedFields == null) {
                selectedFields = new HashSet<>();
            }
            if (!selectedFields.contains(field)) {
                field = field.replaceAll("\\s", "");
                selectedFields.add(field);
            }
        }
    }
    if (selectedFields != null) {
        termVectorsRequest.selectedFields(selectedFields.toArray(new String[selectedFields.size()]));
    }
}
 

import org.elasticsearch.common.Strings; //导入方法依赖的package包/类
@Inject
public AutoCreateIndex(Settings settings, IndexNameExpressionResolver resolver) {
    this.resolver = resolver;
    dynamicMappingDisabled = !settings.getAsBoolean(MapperService.INDEX_MAPPER_DYNAMIC_SETTING, MapperService.INDEX_MAPPER_DYNAMIC_DEFAULT);
    String value = settings.get("action.auto_create_index");
    if (value == null || Booleans.isExplicitTrue(value)) {
        needToCheck = true;
        globallyDisabled = false;
        matches = null;
        matches2 = null;
    } else if (Booleans.isExplicitFalse(value)) {
        needToCheck = false;
        globallyDisabled = true;
        matches = null;
        matches2 = null;
    } else {
        needToCheck = true;
        globallyDisabled = false;
        matches = Strings.commaDelimitedListToStringArray(value);
        matches2 = new String[matches.length];
        for (int i = 0; i < matches.length; i++) {
            matches2[i] = matches[i].substring(1);
        }
    }
}
 

import org.elasticsearch.common.Strings; //导入方法依赖的package包/类
private AutoCreate(String value) {
    boolean autoCreateIndex;
    List<Tuple<String, Boolean>> expressions = new ArrayList<>();
    try {
        autoCreateIndex = Booleans.parseBoolean(value);
    } catch (IllegalArgumentException ex) {
        try {
            String[] patterns = Strings.commaDelimitedListToStringArray(value);
            for (String pattern : patterns) {
                if (pattern == null || pattern.trim().length() == 0) {
                    throw new IllegalArgumentException("Can't parse [" + value + "] for setting [action.auto_create_index] must "
                            + "be either [true, false, or a comma separated list of index patterns]");
                }
                pattern = pattern.trim();
                Tuple<String, Boolean> expression;
                if (pattern.startsWith("-")) {
                    if (pattern.length() == 1) {
                        throw new IllegalArgumentException("Can't parse [" + value + "] for setting [action.auto_create_index] "
                                + "must contain an index name after [-]");
                    }
                    expression = new Tuple<>(pattern.substring(1), false);
                } else if(pattern.startsWith("+")) {
                    if (pattern.length() == 1) {
                        throw new IllegalArgumentException("Can't parse [" + value + "] for setting [action.auto_create_index] "
                                + "must contain an index name after [+]");
                    }
                    expression = new Tuple<>(pattern.substring(1), true);
                } else {
                    expression = new Tuple<>(pattern, true);
                }
                expressions.add(expression);
            }
            autoCreateIndex = true;
        } catch (IllegalArgumentException ex1) {
            ex1.addSuppressed(ex);
            throw ex1;
        }
    }
    this.expressions = expressions;
    this.autoCreateIndex = autoCreateIndex;
    this.string = value;
}
 

import org.elasticsearch.common.Strings; //导入方法依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) throws Exception {
    BulkRequest bulkRequest = Requests.bulkRequest();
    String defaultIndex = request.param("index");
    String defaultType = request.param("type");
    String defaultRouting = request.param("routing");
    String fieldsParam = request.param("fields");
    String[] defaultFields = fieldsParam != null ? Strings.commaDelimitedListToStringArray(fieldsParam) : null;

    String consistencyLevel = request.param("consistency");
    if (consistencyLevel != null) {
        bulkRequest.consistencyLevel(WriteConsistencyLevel.fromString(consistencyLevel));
    }
    bulkRequest.timeout(request.paramAsTime("timeout", BulkShardRequest.DEFAULT_TIMEOUT));
    bulkRequest.refresh(request.paramAsBoolean("refresh", bulkRequest.refresh()));
    bulkRequest.add(request.content(), defaultIndex, defaultType, defaultRouting, defaultFields, null, allowExplicitIndex);

    client.bulk(bulkRequest, new RestBuilderListener<BulkResponse>(channel) {
        @Override
        public RestResponse buildResponse(BulkResponse response, XContentBuilder builder) throws Exception {
            builder.startObject();
            builder.field(Fields.TOOK, response.getTookInMillis());
            builder.field(Fields.ERRORS, response.hasFailures());
            builder.startArray(Fields.ITEMS);
            for (BulkItemResponse itemResponse : response) {
                builder.startObject();
                builder.startObject(itemResponse.getOpType());
                builder.field(Fields._INDEX, itemResponse.getIndex());
                builder.field(Fields._TYPE, itemResponse.getType());
                builder.field(Fields._ID, itemResponse.getId());
                long version = itemResponse.getVersion();
                if (version != -1) {
                    builder.field(Fields._VERSION, itemResponse.getVersion());
                }
                if (itemResponse.isFailed()) {
                    builder.field(Fields.STATUS, itemResponse.getFailure().getStatus().getStatus());
                    builder.startObject(Fields.ERROR);
                    ElasticsearchException.toXContent(builder, request, itemResponse.getFailure().getCause());
                    builder.endObject();
                } else {
                    ActionWriteResponse.ShardInfo shardInfo = itemResponse.getResponse().getShardInfo();
                    shardInfo.toXContent(builder, request);
                    if (itemResponse.getResponse() instanceof DeleteResponse) {
                        DeleteResponse deleteResponse = itemResponse.getResponse();
                        if (deleteResponse.isFound()) {
                            builder.field(Fields.STATUS, shardInfo.status().getStatus());
                        } else {
                            builder.field(Fields.STATUS, RestStatus.NOT_FOUND.getStatus());
                        }
                        builder.field(Fields.FOUND, deleteResponse.isFound());
                    } else if (itemResponse.getResponse() instanceof IndexResponse) {
                        IndexResponse indexResponse = itemResponse.getResponse();
                        if (indexResponse.isCreated()) {
                            builder.field(Fields.STATUS, RestStatus.CREATED.getStatus());
                        } else {
                            builder.field(Fields.STATUS, shardInfo.status().getStatus());
                        }
                    } else if (itemResponse.getResponse() instanceof UpdateResponse) {
                        UpdateResponse updateResponse = itemResponse.getResponse();
                        if (updateResponse.isCreated()) {
                            builder.field(Fields.STATUS, RestStatus.CREATED.getStatus());
                        } else {
                            builder.field(Fields.STATUS, shardInfo.status().getStatus());
                        }
                        if (updateResponse.getGetResult() != null) {
                            builder.startObject(Fields.GET);
                            updateResponse.getGetResult().toXContentEmbedded(builder, request);
                            builder.endObject();
                        }
                    }
                }
                builder.endObject();
                builder.endObject();
            }
            builder.endArray();

            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });
}