import static org.sonar.api.utils.DateUtils.parseEndingDateOrDateTime;
import static org.sonar.api.utils.DateUtils.parseStartingDateOrDateTime;
import static org.sonar.api.web.UserRole.USER;
-import static org.sonar.core.util.stream.MoreCollectors.toHashSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.newcodeperiod.NewCodePeriodType.REFERENCE_BRANCH;
import static org.sonarqube.ws.client.issue.IssuesWsParameters.PARAM_COMPONENT_KEYS;
return;
}
- Set<String> qualifiers = components.stream().map(ComponentDto::qualifier).collect(toHashSet());
+ Set<String> qualifiers = components.stream().map(ComponentDto::qualifier).collect(Collectors.toSet());
checkArgument(qualifiers.size() == 1, "All components must have the same qualifier, found %s", String.join(",", qualifiers));
setBranch(builder, components.get(0), request.getBranch(), request.getPullRequest(), dbSession);
PermissionIndexerDao permissionIndexerDao = new PermissionIndexerDao();
Set<String> remainingEntityUuids = items.stream().map(EsQueueDto::getDocId)
.map(AuthorizationDoc::entityUuidOf)
- .collect(MoreCollectors.toHashSet());
+ .collect(Collectors.toSet());
permissionIndexerDao.selectByUuids(dbClient, dbSession, remainingEntityUuids).forEach(p -> {
remainingEntityUuids.remove(p.getEntityUuid());
bulkIndexers.forEach(bi -> bi.add(AuthorizationDoc.fromDto(bi.getIndexType(), p).toIndexRequest()));
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Arrays.asList;
-import static org.sonar.core.util.stream.MoreCollectors.toHashSet;
import static org.sonar.db.measure.ProjectMeasuresIndexerIterator.METRIC_KEYS;
import static org.sonar.server.measure.index.ProjectMeasuresQuery.MetricCriterion;
import static org.sonar.server.measure.index.ProjectMeasuresQuery.SORT_BY_LAST_ANALYSIS_DATE;
}
public static void validate(ProjectMeasuresQuery query) {
- validateFilterKeys(query.getMetricCriteria().stream().map(MetricCriterion::getMetricKey).collect(toHashSet()));
+ validateFilterKeys(query.getMetricCriteria().stream().map(MetricCriterion::getMetricKey).collect(Collectors.toSet()));
validateSort(query.getSort());
}
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.resources.ResourceTypes;
import static org.sonar.api.resources.Qualifiers.PROJECT;
import static org.sonar.api.resources.Qualifiers.SUBVIEW;
import static org.sonar.api.resources.Qualifiers.VIEW;
-import static org.sonar.core.util.stream.MoreCollectors.toHashSet;
import static org.sonar.server.es.SearchOptions.MAX_PAGE_SIZE;
-import static org.sonar.server.ws.WsParameterBuilder.QualifierParameterContext.newQualifierParameterContext;
import static org.sonar.server.ws.WsParameterBuilder.createQualifiersParameter;
+import static org.sonar.server.ws.WsParameterBuilder.QualifierParameterContext.newQualifierParameterContext;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
import static org.sonarqube.ws.client.component.ComponentsWsParameters.ACTION_SEARCH;
import static org.sonarqube.ws.client.component.ComponentsWsParameters.PARAM_QUALIFIERS;
private Map<String, String> searchProjectsKeysByUuids(DbSession dbSession, List<EntityDto> entities) {
Set<String> projectUuidsToSearch = entities.stream()
.map(EntityDto::getAuthUuid)
- .collect(toHashSet());
+ .collect(Collectors.toSet());
List<EntityDto> projects = dbClient.entityDao().selectByUuids(dbSession, projectUuidsToSearch);
return projects.stream().collect(toMap(EntityDto::getUuid, EntityDto::getKey));
}
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.SnapshotDto;
import org.sonar.db.measure.MeasureDto;
}
public SearchHistoryResult setMeasures(List<MeasureDto> measures) {
- Set<String> analysisUuids = analyses.stream().map(SnapshotDto::getUuid).collect(MoreCollectors.toHashSet());
+ Set<String> analysisUuids = analyses.stream().map(SnapshotDto::getUuid).collect(Collectors.toSet());
ImmutableList.Builder<MeasureDto> measuresBuilder = ImmutableList.builder();
List<MeasureDto> filteredMeasures = measures.stream()
.filter(measure -> analysisUuids.contains(measure.getAnalysisUuid()))
Set<String> deactivatedRuleUuids = dbClient.activeRuleDao().selectByRuleProfile(dbSession, initialRuleProfile)
.stream()
.map(ActiveRuleDto::getRuleUuid)
- .collect(MoreCollectors.toHashSet());
+ .collect(Collectors.toSet());
// all rules, including those which are removed from built-in profile
Set<String> ruleUuids = Stream.concat(
Collection<QProfileDto> profiles = db.qualityProfileDao().selectDescendants(dbSession, parents);
Set<String> ruleProfileUuids = profiles.stream()
.map(QProfileDto::getRulesProfileUuid)
- .collect(MoreCollectors.toHashSet());
+ .collect(Collectors.toSet());
Collection<ActiveRuleDto> activeRules = db.activeRuleDao().selectByRulesAndRuleProfileUuids(dbSession, ruleUuids, ruleProfileUuids);
List<String> activeRuleUuids = activeRules.stream().map(ActiveRuleDto::getUuid).collect(Collectors.toList());
List<ActiveRuleParamDto> activeRuleParams = db.activeRuleDao().selectParamsByActiveRuleUuids(dbSession, activeRuleUuids);
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
return Collectors.toCollection(() -> EnumSet.noneOf(enumClass));
}
- public static <T> Collector<T, ?, HashSet<T>> toHashSet() {
- return java.util.stream.Collectors.toCollection(HashSet::new);
- }
-
- public static <T> Collector<T, ?, HashSet<T>> toHashSet(int size) {
- return java.util.stream.Collectors.toCollection(() -> new HashSet<>(size));
+ public static <T> Collector<T, ?, Set<T>> toHashSet(int size) {
+ return Collectors.toSet();
}
/**
.isEmpty();
}
- @Test
- public void toHashSet_builds_an_HashSet() {
- Set<Integer> res = Stream.of(1, 2, 3, 4, 5).collect(toHashSet());
- assertThat(res).isInstanceOf(HashSet.class)
- .containsExactly(1, 2, 3, 4, 5);
- }
-
- @Test
- public void toHashSet_parallel_stream() {
- assertThat(HUGE_SET.parallelStream().collect(toHashSet())).isEqualTo(HUGE_SET);
- }
-
@Test
public void toHashSet_with_size_builds_an_ArrayList() {
Set<Integer> res = Stream.of(1, 2, 3, 4, 5).collect(toHashSet(30));