Java Regex.simpleMatch方法代码示例

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
private Table buildTable(RestRequest request, ClusterStateResponse clusterStateResponse, String patternString) {
    Table table = getTableWithHeader(request);
    MetaData metadata = clusterStateResponse.getState().metaData();
    for (ObjectObjectCursor<String, IndexTemplateMetaData> entry : metadata.templates()) {
        IndexTemplateMetaData indexData = entry.value;
        if (patternString == null || Regex.simpleMatch(patternString, indexData.name())) {
            table.startRow();
            table.addCell(indexData.name());
            table.addCell("[" + String.join(", ", indexData.patterns()) + "]");
            table.addCell(indexData.getOrder());
            table.addCell(indexData.getVersion());
            table.endRow();
        }
    }
    return table;
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
@Override
protected void masterOperation(GetIndexTemplatesRequest request, ClusterState state, ActionListener<GetIndexTemplatesResponse> listener) {
    List<IndexTemplateMetaData> results;

    // If we did not ask for a specific name, then we return all templates
    if (request.names().length == 0) {
        results = Arrays.asList(state.metaData().templates().values().toArray(IndexTemplateMetaData.class));
    } else {
        results = new ArrayList<>();
    }

    for (String name : request.names()) {
        if (Regex.isSimpleMatchPattern(name)) {
            for (ObjectObjectCursor<String, IndexTemplateMetaData> entry : state.metaData().templates()) {
                if (Regex.simpleMatch(name, entry.key)) {
                    results.add(entry.value);
                }
            }
        } else if (state.metaData().templates().containsKey(name)) {
            results.add(state.metaData().templates().get(name));
        }
    }

    listener.onResponse(new GetIndexTemplatesResponse(results));
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
public boolean match(Task task) {
    if (getActions() != null && getActions().length > 0 && Regex.simpleMatch(getActions(), task.getAction()) == false) {
        return false;
    }
    if (getTaskId().isSet()) {
        if(getTaskId().getId() != task.getId()) {
            return false;
        }
    }
    if (parentTaskId.isSet()) {
        if (parentTaskId.equals(task.getParentTaskId()) == false) {
            return false;
        }
    }
    return true;
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
private static Settings filterSettings(Iterable<String> patterns, Settings settings) {
    Settings.Builder builder = Settings.builder().put(settings);
    List<String> simpleMatchPatternList = new ArrayList<>();
    for (String pattern : patterns) {
        if (Regex.isSimpleMatchPattern(pattern)) {
            simpleMatchPatternList.add(pattern);
        } else {
            builder.remove(pattern);
        }
    }
    if (!simpleMatchPatternList.isEmpty()) {
        String[] simpleMatchPatterns = simpleMatchPatternList.toArray(new String[simpleMatchPatternList.size()]);
        Iterator<Entry<String, String>> iterator = builder.internalMap().entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> current = iterator.next();
            if (Regex.simpleMatch(simpleMatchPatterns, current.getKey())) {
                iterator.remove();
            }
        }
    }
    return builder.build();
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
ClusterState innerDelete(DeletePipelineRequest request, ClusterState currentState) {
    IngestMetadata currentIngestMetadata = currentState.metaData().custom(IngestMetadata.TYPE);
    if (currentIngestMetadata == null) {
        return currentState;
    }
    Map<String, PipelineConfiguration> pipelines = currentIngestMetadata.getPipelines();
    Set<String> toRemove = new HashSet<>();
    for (String pipelineKey : pipelines.keySet()) {
        if (Regex.simpleMatch(request.getId(), pipelineKey)) {
            toRemove.add(pipelineKey);
        }
    }
    if (toRemove.isEmpty() && Regex.isMatchAllPattern(request.getId()) == false) {
        throw new ResourceNotFoundException("pipeline [{}] is missing", request.getId());
    } else if (toRemove.isEmpty()) {
        return currentState;
    }
    final Map<String, PipelineConfiguration> pipelinesCopy = new HashMap<>(pipelines);
    for (String key : toRemove) {
        pipelinesCopy.remove(key);
    }
    ClusterState.Builder newState = ClusterState.builder(currentState);
    newState.metaData(MetaData.builder(currentState.getMetaData())
            .putCustom(IngestMetadata.TYPE, new IngestMetadata(pipelinesCopy))
            .build());
    return newState.build();
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
List<PipelineConfiguration> innerGetPipelines(IngestMetadata ingestMetadata, String... ids) {
    if (ingestMetadata == null) {
        return Collections.emptyList();
    }

    // if we didn't ask for _any_ ID, then we get them all (this is the same as if they ask for '*')
    if (ids.length == 0) {
        return new ArrayList<>(ingestMetadata.getPipelines().values());
    }

    List<PipelineConfiguration> result = new ArrayList<>(ids.length);
    for (String id : ids) {
        if (Regex.isSimpleMatchPattern(id)) {
            for (Map.Entry<String, PipelineConfiguration> entry : ingestMetadata.getPipelines().entrySet()) {
                if (Regex.simpleMatch(id, entry.getKey())) {
                    result.add(entry.getValue());
                }
            }
        } else {
            PipelineConfiguration pipeline = ingestMetadata.getPipelines().get(id);
            if (pipeline != null) {
                result.add(pipeline);
            }
        }
    }
    return result;
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
public FieldDataStats stats(String... fields) {
    ObjectLongHashMap<String> fieldTotals = null;
    if (fields != null && fields.length > 0) {
        fieldTotals = new ObjectLongHashMap<>();
        for (Map.Entry<String, CounterMetric> entry : perFieldTotals.entrySet()) {
            if (Regex.simpleMatch(fields, entry.getKey())) {
                fieldTotals.put(entry.getKey(), entry.getValue().count());
            }
        }
    }
    return new FieldDataStats(totalMetric.count(), evictionsMetric.count(), fieldTotals == null ? null :
        new FieldMemoryStats(fieldTotals));
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
public boolean hasDynamicSetting(String key) {
    for (String dynamicSetting : dynamicSettings.keySet()) {
        if (Regex.simpleMatch(dynamicSetting, key)) {
            return true;
        }
    }
    return false;
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
public Collection<String> simpleMatchToFullName(String pattern) {
    Set<String> fields = new HashSet<>();
    for (FieldMapper fieldMapper : this) {
        if (Regex.simpleMatch(pattern, fieldMapper.fieldType().name())) {
            fields.add(fieldMapper.fieldType().name());
        }
    }
    return fields;
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
private boolean shouldTraceAction(String action) {
    if (tracerLogInclude.length > 0) {
        if (Regex.simpleMatch(tracerLogInclude, action) == false) {
            return false;
        }
    }
    if (tracelLogExclude.length > 0) {
        return !Regex.simpleMatch(tracelLogExclude, action);
    }
    return true;
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
private void addNewIndex(ClusterState tribeState, ClusterBlocks.Builder blocks, MetaData.Builder metaData,
                         RoutingTable.Builder routingTable, IndexMetaData tribeIndex) {
    Settings tribeSettings = Settings.builder().put(tribeIndex.getSettings()).put(TRIBE_NAME_SETTING.getKey(), tribeName).build();
    metaData.put(IndexMetaData.builder(tribeIndex).settings(tribeSettings));
    routingTable.add(tribeState.routingTable().index(tribeIndex.getIndex()));
    if (Regex.simpleMatch(blockIndicesMetadata, tribeIndex.getIndex().getName())) {
        blocks.addIndexBlock(tribeIndex.getIndex().getName(), IndexMetaData.INDEX_METADATA_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesRead, tribeIndex.getIndex().getName())) {
        blocks.addIndexBlock(tribeIndex.getIndex().getName(), IndexMetaData.INDEX_READ_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesWrite, tribeIndex.getIndex().getName())) {
        blocks.addIndexBlock(tribeIndex.getIndex().getName(), IndexMetaData.INDEX_WRITE_BLOCK);
    }
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
@Override
protected void masterOperation(GetSettingsRequest request, ClusterState state, ActionListener<GetSettingsResponse> listener) {
    String[] concreteIndices = indexNameExpressionResolver.concreteIndices(state, request);
    ImmutableOpenMap.Builder<String, Settings> indexToSettingsBuilder = ImmutableOpenMap.builder();
    for (String concreteIndex : concreteIndices) {
        IndexMetaData indexMetaData = state.getMetaData().index(concreteIndex);
        if (indexMetaData == null) {
            continue;
        }

        Settings settings = SettingsFilter.filterSettings(settingsFilter.getPatterns(), indexMetaData.getSettings());
        if (request.humanReadable()) {
            settings = IndexMetaData.addHumanReadableSettings(settings);
        }
        if (!CollectionUtils.isEmpty(request.names())) {
            Settings.Builder settingsBuilder = Settings.builder();
            for (Map.Entry<String, String> entry : settings.getAsMap().entrySet()) {
                if (Regex.simpleMatch(request.names(), entry.getKey())) {
                    settingsBuilder.put(entry.getKey(), entry.getValue());
                }
            }
            settings = settingsBuilder.build();
        }
        indexToSettingsBuilder.put(concreteIndex, settings);
    }
    listener.onResponse(new GetSettingsResponse(indexToSettingsBuilder.build()));
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
private boolean matchByIP(String[] values, @Nullable String hostIp, @Nullable String publishIp) {
    for (String value : values) {
        boolean matchIp = Regex.simpleMatch(value, hostIp) || Regex.simpleMatch(value, publishIp);
        if (matchIp) {
            return matchIp;
        }
    }
    return false;
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
private void addNewIndex(ClusterState tribeState, ClusterBlocks.Builder blocks, MetaData.Builder metaData, RoutingTable.Builder routingTable, IndexMetaData tribeIndex) {
    Settings tribeSettings = Settings.builder().put(tribeIndex.getSettings()).put(TRIBE_NAME, tribeName).build();
    metaData.put(IndexMetaData.builder(tribeIndex).settings(tribeSettings));
    routingTable.add(tribeState.routingTable().index(tribeIndex.getIndex()));
    if (Regex.simpleMatch(blockIndicesMetadata, tribeIndex.getIndex())) {
        blocks.addIndexBlock(tribeIndex.getIndex(), IndexMetaData.INDEX_METADATA_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesRead, tribeIndex.getIndex())) {
        blocks.addIndexBlock(tribeIndex.getIndex(), IndexMetaData.INDEX_READ_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesWrite, tribeIndex.getIndex())) {
        blocks.addIndexBlock(tribeIndex.getIndex(), IndexMetaData.INDEX_WRITE_BLOCK);
    }
}
 

import org.elasticsearch.common.regex.Regex; //导入方法依赖的package包/类
/**
 * Returns a list of the index names of a simple match regex like pattern against full name and index name.
 */
public Collection<String> simpleMatchToIndexNames(String pattern) {
    Set<String> fields = Sets.newHashSet();
    for (MappedFieldType fieldType : this) {
        if (Regex.simpleMatch(pattern, fieldType.names().fullName())) {
            fields.add(fieldType.names().indexName());
        } else if (Regex.simpleMatch(pattern, fieldType.names().indexName())) {
            fields.add(fieldType.names().indexName());
        }
    }
    return fields;
}