.filter(Optional::isPresent)
.map(Optional::get)
.map(CeTaskSubmit.Component::getEntityUuid)
- .collect(MoreCollectors.toSet(submissions.size()));
+ .collect(Collectors.toSet());
if (mainComponentUuids.isEmpty()) {
return t -> true;
}
// load characteristics
// TODO could be avoided, characteristics are already present in submissions
- Set<String> taskUuids = dtos.stream().map(CeQueueDto::getUuid).collect(MoreCollectors.toSet(dtos.size()));
+ Set<String> taskUuids = dtos.stream().map(CeQueueDto::getUuid).collect(Collectors.toSet());
Multimap<String, CeTaskCharacteristicDto> characteristicsByTaskUuid = dbClient.ceTaskCharacteristicsDao()
.selectByTaskUuids(dbSession, taskUuids).stream()
.collect(MoreCollectors.index(CeTaskCharacteristicDto::getTaskUuid));
import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.ce.ComputeEngineSide;
import org.sonar.ce.task.projectanalysis.component.TypeAwareVisitorAdapter;
import org.sonar.ce.task.projectanalysis.issue.RuleRepository;
import org.sonar.core.issue.DefaultIssue;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.user.UserDto;
import org.sonar.server.issue.notification.IssuesChangesNotification;
import org.sonar.server.issue.notification.IssuesChangesNotificationBuilder;
.setRule(getRuleByRuleKey(issue.ruleKey()))
.setProject(getProject())
.build())
- .collect(MoreCollectors.toSet(issues.size()));
+ .collect(Collectors.toSet());
return issuesChangesSerializer.serialize(new IssuesChangesNotificationBuilder(changedIssues, change));
}
import java.util.Collection;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.sonar.api.web.UserRole;
import org.sonar.server.notification.EmailNotificationHandler;
import static java.util.Collections.emptySet;
import static org.sonar.core.util.stream.MoreCollectors.index;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
public class ReportAnalysisFailureNotificationHandler extends EmailNotificationHandler<ReportAnalysisFailureNotification> {
private static final String KEY = "CeReportTaskFailure";
return notificationsByProjectKey.asMap().entrySet()
.stream()
.flatMap(e -> toEmailDeliveryRequests(e.getKey(), e.getValue()))
- .collect(toSet(notifications.size()));
+ .collect(Collectors.toSet());
}
private Stream<? extends EmailDeliveryRequest> toEmailDeliveryRequests(String projectKey, Collection<ReportAnalysisFailureNotification> notifications) {
import org.sonar.ce.task.projectanalysis.component.ProjectPersister;
import org.sonar.ce.task.projectanalysis.component.TreeRootHolder;
import org.sonar.ce.task.step.ComputationStep;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.ComponentDto;
Set<String> uuids = dtos.stream()
.filter(ComponentDto::isEnabled)
.map(ComponentDto::uuid)
- .collect(MoreCollectors.toSet(dtos.size()));
+ .collect(Collectors.toSet());
dbClient.componentDao().updateBEnabledToFalse(dbSession, uuids);
disabledComponentsHolder.setUuids(uuids);
}
import static java.util.Collections.singleton;
import static java.util.stream.Collectors.toMap;
import static java.util.stream.StreamSupport.stream;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.db.component.BranchType.PULL_REQUEST;
/**
return myNewIssuesNotification;
})
- .collect(toSet(statistics.getAssigneesStatistics().size()));
+ .collect(Collectors.toSet());
notificationStatistics.myNewIssuesDeliveries += service.deliverEmails(myNewIssuesNotifications);
notificationStatistics.myNewIssues += myNewIssuesNotifications.size();
import org.sonar.process.cluster.hz.HazelcastMember;
import org.sonar.process.cluster.hz.HazelcastObjects;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.process.cluster.hz.HazelcastObjects.WORKER_UUIDS;
/**
@Override
public void broadcastWorkerUUIDs() {
Set<CeWorker> workers = ceCeWorkerFactory.getWorkers();
- Set<String> workerUuids = workers.stream().map(CeWorker::getUUID).collect(toSet(workers.size()));
+ Set<String> workerUuids = workers.stream().map(CeWorker::getUUID).collect(Collectors.toSet());
getClusteredWorkerUUIDs().put(hazelcastMember.getUuid(), workerUuids);
}
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
+import java.util.stream.Collectors;
import org.sonar.ce.taskprocessor.CeWorker;
import org.sonar.ce.taskprocessor.CeWorkerFactory;
import static com.google.common.base.Preconditions.checkState;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
/**
* Provide the set of worker's UUID in a non clustered SonarQube instance
@Override
public void broadcastWorkerUUIDs() {
Set<CeWorker> workers = ceCeWorkerFactory.getWorkers();
- workerUUIDs = workers.stream().map(CeWorker::getUUID).collect(toSet(workers.size()));
+ workerUUIDs = workers.stream().map(CeWorker::getUUID).collect(Collectors.toSet());
}
/**
import java.util.Collections;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.sonar.ce.queue.InternalCeQueue;
import org.sonar.core.util.UuidFactory;
-import org.sonar.core.util.stream.MoreCollectors;
import org.springframework.beans.factory.annotation.Autowired;
public class CeWorkerFactoryImpl implements CeWorkerFactory {
public CeWorker create(int ordinal) {
String uuid = uuidFactory.create();
CeWorkerImpl ceWorker = new CeWorkerImpl(ordinal, uuid, queue, taskProcessorRepository, ceWorkerController, executionListeners);
- ceWorkers = Stream.concat(ceWorkers.stream(), Stream.of(ceWorker)).collect(MoreCollectors.toSet(ceWorkers.size() + 1));
+ ceWorkers = Stream.concat(ceWorkers.stream(), Stream.of(ceWorker)).collect(Collectors.toSet());
return ceWorker;
}
import java.util.Collection;
import java.util.stream.Collectors;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbSession;
import org.sonar.db.component.BranchDto;
import org.sonar.db.entity.EntityDto;
default void commitAndIndexEntities(DbSession dbSession, Collection<? extends EntityDto> entities, EntityEvent cause) {
Collection<String> entityUuids = entities.stream()
.map(EntityDto::getUuid)
- .collect(MoreCollectors.toSet(entities.size()));
+ .collect(Collectors.toSet());
commitAndIndexOnEntityEvent(dbSession, entityUuids, cause);
}
import java.util.Optional;
import java.util.Set;
import java.util.function.BiPredicate;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.es.searchrequest.TopAggregationDefinition.FilterScope;
import static com.google.common.base.Preconditions.checkArgument;
Set<FilterScope> enabledStickyTopAggregationtedFieldNames = topAggregations.stream()
.filter(TopAggregationDefinition::isSticky)
.map(TopAggregationDefinition::getFilterScope)
- .collect(MoreCollectors.toSet(topAggregations.size()));
+ .collect(Collectors.toSet());
// use LinkedHashMap over MoreCollectors.uniqueIndex to preserve order and write UTs more easily
Map<FilterNameAndScope, QueryBuilder> res = new LinkedHashMap<>();
import org.sonar.server.notification.email.EmailNotificationChannel;
import org.sonar.server.notification.email.EmailNotificationChannel.EmailDeliveryRequest;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.unorderedFlattenIndex;
import static org.sonar.core.util.stream.MoreCollectors.unorderedIndex;
import static org.sonar.server.notification.NotificationManager.SubscriberPermissionsOnProject.ALL_MUST_HAVE_ROLE_USER;
.filter(notification -> !notification.getChange().isAuthorLogin(recipient.login()))
.map(notification -> toEmailDeliveryRequest(notification, recipient, projectKeys)))
.filter(Objects::nonNull)
- .collect(toSet(notificationsWithPeerChangedIssues.size()));
+ .collect(Collectors.toSet());
}
SetMultimap<String, String> assigneeLoginsOfPeerChangedIssuesByProjectKey = notificationsWithPeerChangedIssues.stream()
.map(notification -> toEmailDeliveryRequest(notification, recipient, subscribedProjectKeys))
.filter(Objects::nonNull);
})
- .collect(toSet(notificationsWithPeerChangedIssues.size()));
+ .collect(Collectors.toSet());
}
/**
*/
@CheckForNull
private static EmailDeliveryRequest toEmailDeliveryRequest(NotificationWithProjectKeys notification, EmailRecipient recipient, Set<String> subscribedProjectKeys) {
+ notification.getIssues();
Set<ChangedIssue> recipientIssuesByProject = notification.getIssues().stream()
.filter(issue -> issue.getAssignee().filter(assignee -> recipient.login().equals(assignee.getLogin())).isPresent())
.filter(issue -> subscribedProjectKeys.contains(issue.getProject().getKey()))
- .collect(toSet(notification.getIssues().size()));
+ .collect(Collectors.toSet());
if (recipientIssuesByProject.isEmpty()) {
return null;
}
import static java.util.Collections.emptySet;
import static java.util.Optional.of;
import static java.util.Optional.ofNullable;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.unorderedFlattenIndex;
import static org.sonar.core.util.stream.MoreCollectors.unorderedIndex;
import static org.sonar.server.issue.notification.FPOrWontFixNotification.FpOrWontFix.FP;
Set<EmailRecipient> recipients = notificationManager.findSubscribedEmailRecipients(KEY, projectKeys.iterator().next(), ALL_MUST_HAVE_ROLE_USER);
return changeNotificationsWithFpOrWontFix.stream()
.flatMap(notification -> toRequests(notification, projectKeys, recipients))
- .collect(toSet(changeNotificationsWithFpOrWontFix.size()));
+ .collect(Collectors.toSet());
}
Set<EmailRecipientAndProject> recipientsByProjectKey = projectKeys.stream()
return recipientsByProjectKeys.asMap().entrySet().stream()
.flatMap(entry -> toRequests(notification, entry.getKey(), entry.getValue()));
})
- .collect(toSet(changeNotificationsWithFpOrWontFix.size()));
+ .collect(Collectors.toSet());
}
private static Stream<EmailDeliveryRequest> toRequests(NotificationWithProjectKeys notification, Set<String> projectKeys, Collection<EmailRecipient> recipients) {
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Optional.ofNullable;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
public class IssuesChangesNotificationSerializer {
.setRule(rules.get(issue.ruleKey))
.setProject(projects.get(issue.projectUuid))
.build())
- .collect(toSet(issues.size()));
+ .collect(Collectors.toSet());
}
private static void serializeIssues(IssuesChangesNotification res, Set<ChangedIssue> issues) {
return notificationsByProjectKey.asMap().entrySet()
.stream()
.flatMap(e -> toEmailDeliveryRequests(e.getKey(), e.getValue()))
- .collect(MoreCollectors.toSet(notifications.size()));
+ .collect(Collectors.toSet());
}
private Stream<? extends EmailDeliveryRequest> toEmailDeliveryRequests(String projectKey, Collection<MyNewIssuesNotification> notifications) {
import java.util.Collection;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.sonar.server.notification.EmailNotificationHandler;
import org.sonar.server.notification.NotificationDispatcherMetadata;
import static java.util.Collections.emptySet;
import static org.sonar.core.util.stream.MoreCollectors.index;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.server.notification.NotificationManager.SubscriberPermissionsOnProject.ALL_MUST_HAVE_ROLE_USER;
public class NewIssuesNotificationHandler extends EmailNotificationHandler<NewIssuesNotification> {
return notificationsByProjectKey.asMap().entrySet()
.stream()
.flatMap(e -> toEmailDeliveryRequests(e.getKey(), e.getValue()))
- .collect(toSet(notifications.size()));
+ .collect(Collectors.toSet());
}
private Stream<? extends EmailDeliveryRequest> toEmailDeliveryRequests(String projectKey, Collection<NewIssuesNotification> notifications) {
import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.ce.ComputeEngineSide;
import org.sonar.api.server.ServerSide;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.springframework.beans.factory.annotation.Autowired;
.filter(Optional::isPresent)
.map(Optional::get)
.map(NotificationDispatcherMetadata::getDispatcherKey)
- .collect(MoreCollectors.toSet(notificationTypes.size()));
+ .collect(Collectors.toSet());
return dbClient.propertiesDao().hasProjectNotificationSubscribersForDispatchers(projectUuid, dispatcherKeys);
}
import java.util.Objects;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.concurrent.Immutable;
import static java.util.Objects.requireNonNull;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
@Immutable
public class QualityGate {
this.conditions = requireNonNull(conditions, "conditions can't be null")
.stream()
.map(c -> requireNonNull(c, "condition can't be null"))
- .collect(toSet(conditions.size()));
+ .collect(Collectors.toSet());
}
public String getId() {
import java.util.Collection;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.sonar.server.notification.EmailNotificationHandler;
import org.sonar.server.notification.NotificationDispatcherMetadata;
import static java.util.Collections.emptySet;
import static org.sonar.core.util.stream.MoreCollectors.index;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.server.notification.NotificationManager.SubscriberPermissionsOnProject.ALL_MUST_HAVE_ROLE_USER;
public class QGChangeNotificationHandler extends EmailNotificationHandler<QGChangeNotification> {
return notificationsByProjectKey.asMap().entrySet()
.stream()
.flatMap(e -> toEmailDeliveryRequests(e.getKey(), e.getValue()))
- .collect(toSet(notifications.size()));
+ .collect(Collectors.toSet());
}
private Stream<? extends EmailDeliveryRequest> toEmailDeliveryRequests(String projectKey, Collection<QGChangeNotification> notifications) {
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import static org.elasticsearch.index.query.QueryBuilders.termQuery;
import static org.sonar.core.util.stream.MoreCollectors.toArrayList;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.server.qualityprofile.index.ActiveRuleDoc.docIdOf;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_PROFILE_UUID;
import static org.sonar.server.rule.index.RuleIndexDefinition.TYPE_ACTIVE_RULE;
Set<String> docIds = activeRuleItems.keySet();
return docIds.stream()
.map(ActiveRuleDoc::activeRuleUuidOf)
- .collect(toSet(docIds.size()));
+ .collect(Collectors.toSet());
}
private IndexingResult doIndexRuleProfiles(DbSession dbSession, Map<String, EsQueueDto> ruleProfileItems) {
import javax.annotation.Nullable;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.Scopes;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.BranchDto;
}
return permissionKeys.stream()
.map(GlobalPermission::fromKey)
- .collect(MoreCollectors.toSet(permissionKeys.size()));
+ .collect(toSet());
}
private Set<String> loadDbPermissions(DbSession dbSession, String entityUuid) {
Set<String> copyComponentsUuid = components.stream()
.map(ComponentDto::getCopyComponentUuid)
.filter(Objects::nonNull)
- .collect(MoreCollectors.toSet(components.size()));
+ .collect(toSet());
return dbClient.componentDao().selectByUuids(dbSession, copyComponentsUuid).stream()
.collect(Collectors.toMap(ComponentDto::uuid, componentDto -> componentDto));
}
import java.util.Objects;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.server.rule.RulesDefinition;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.rule.DeprecatedRuleKeyDto;
@Immutable
}
public static Set<SingleDeprecatedRuleKey> from(RulesDefinition.Rule rule) {
+ rule.deprecatedRuleKeys();
return rule.deprecatedRuleKeys().stream()
.map(r -> new SingleDeprecatedRuleKey()
.setNewRepositoryKey(rule.repository().key())
.setNewRuleKey(rule.key())
.setOldRepositoryKey(r.repository())
.setOldRuleKey(r.rule()))
- .collect(MoreCollectors.toSet(rule.deprecatedRuleKeys().size()));
+ .collect(Collectors.toSet());
}
public static SingleDeprecatedRuleKey from(DeprecatedRuleKeyDto rule) {
import org.sonar.api.server.rule.RulesDefinition.PciDssVersion;
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.System2;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.es.EsClient;
import org.sonar.server.es.EsUtils;
import org.sonar.server.es.SearchOptions;
.map(FACETS_BY_NAME::get)
.filter(Objects::nonNull)
.map(Facet::getTopAggregationDef))
- .collect(MoreCollectors.toSet(facetNames.size()));
+ .collect(Collectors.toSet());
return new RequestFiltersComputer(allFilters, facets);
}
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rules.RuleType;
import org.sonar.api.server.ServerSide;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.BranchDto;
public static final Set<String> ISSUE_TYPE_NAMES = Arrays.stream(RuleType.values())
.filter(t -> t != RuleType.SECURITY_HOTSPOT)
.map(Enum::name)
- .collect(MoreCollectors.toSet(RuleType.values().length - 1));
+ .collect(Collectors.toSet());
private static final ComponentDto UNKNOWN_COMPONENT = new ComponentDto().setUuid(UNKNOWN).setBranchUuid(UNKNOWN);
private static final Set<String> QUALIFIERS_WITHOUT_LEAK_PERIOD = new HashSet<>(Arrays.asList(Qualifiers.APP, Qualifiers.VIEW, Qualifiers.SUBVIEW));
private final DbClient dbClient;
import static org.sonar.api.measures.CoreMetrics.SECURITY_RATING_KEY;
import static org.sonar.api.measures.CoreMetrics.SECURITY_REVIEW_RATING_KEY;
import static org.sonar.api.measures.CoreMetrics.SQALE_RATING_KEY;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.server.es.EsUtils.escapeSpecialRegexChars;
import static org.sonar.server.es.EsUtils.termsToMap;
.map(FACETS_BY_NAME::get)
.filter(Objects::nonNull)
.map(Facet::getTopAggregationDef)
- .collect(toSet(facetNames.size()));
+ .collect(Collectors.toSet());
return new RequestFiltersComputer(allFilters, facets);
}
import java.util.Arrays;
import java.util.Random;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.junit.Rule;
import org.sonar.api.web.UserRole;
import org.sonar.core.util.SequenceUuidFactory;
import org.sonar.core.util.Uuids;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
private static final String PRIVATE = "private";
private static final Set<String> GLOBAL_PERMISSIONS_NAME_SET = stream(GlobalPermission.values()).map(GlobalPermission::getKey)
- .collect(MoreCollectors.toSet(GlobalPermission.values().length));
+ .collect(Collectors.toSet());
@Rule
public final DbTester dbTester = DbTester.create(System2.INSTANCE);
private final ResourceTypes resourceTypes = new ResourceTypesRule().setRootQualifiers(Qualifiers.PROJECT);
private final PermissionService permissionService = new PermissionServiceImpl(resourceTypes);
private final Set<String> PROJECT_PERMISSIONS_BUT_USER_AND_CODEVIEWER = permissionService.getAllProjectPermissions().stream()
- .filter(perm -> !perm.equals(UserRole.USER) && !perm.equals(UserRole.CODEVIEWER))
- .collect(MoreCollectors.toSet(permissionService.getAllProjectPermissions().size() - 2));
+ .filter(perm -> !perm.equals(UserRole.USER) && !perm.equals(UserRole.CODEVIEWER))
+ .collect(Collectors.toSet());
private final DbClient dbClient = dbTester.getDbClient();
private final DbSession dbSession = dbTester.getSession();
import static java.util.Collections.singletonList;
import static java.util.Optional.ofNullable;
import static org.sonar.api.utils.DateUtils.formatDateTime;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
/**
.filter(Objects::nonNull)
.map(CeQueueDto::getComponentUuid)
.filter(Objects::nonNull)
- .collect(toSet(ceQueueDtos.size()));
+ .collect(Collectors.toSet());
}
static DtoCache forActivityDtos(DbClient dbClient, DbSession dbSession, Collection<CeActivityDto> ceActivityDtos) {
.filter(Objects::nonNull)
.map(CeActivityDto::getComponentUuid)
.filter(Objects::nonNull)
- .collect(toSet(ceActivityDtos.size()));
+ .collect(Collectors.toSet());
}
@CheckForNull
import java.util.Collection;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.ResourceType;
import org.sonar.api.resources.ResourceTypes;
import org.sonar.api.resources.Scopes;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.BranchDto;
return rootTypes
.stream()
.map(ResourceType::getQualifier)
- .collect(MoreCollectors.toSet(rootTypes.size()));
+ .collect(Collectors.toSet());
}
public ComponentDto getByKeyAndBranch(DbSession dbSession, String key, String branch) {
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.core.platform.EditionProvider.Edition;
import org.sonar.core.platform.PlatformEditionProvider;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.BranchDto;
Set<String> favoriteDbUuids = props.stream()
.map(PropertyDto::getEntityUuid)
.filter(Objects::nonNull)
- .collect(MoreCollectors.toSet(props.size()));
+ .collect(Collectors.toSet());
return dbClient.projectDao().selectByUuids(dbSession, favoriteDbUuids).stream()
.map(ProjectDto::getUuid)
return newBuilder().build();
}
- Set<String> favoriteUuids = favorites.stream().map(EntityDto::getUuid).collect(MoreCollectors.toSet(favorites.size()));
+ Set<String> favoriteUuids = favorites.stream().map(EntityDto::getUuid).collect(Collectors.toSet());
Comparator<EntityDto> favoriteComparator = Comparator.comparing(c -> favoriteUuids.contains(c.getUuid()) ? -1 : +1);
Comparator<EntityDto> comparator = favoriteComparator.thenComparing(EntityDto::getName);
}
List<EntityDto> favorites = favoriteFinder.list();
- Set<String> favoriteKeys = favorites.stream().map(EntityDto::getKey).collect(MoreCollectors.toSet(favorites.size()));
+ Set<String> favoriteKeys = favorites.stream().map(EntityDto::getKey).collect(Collectors.toSet());
SuggestionQuery.Builder queryBuilder = SuggestionQuery.builder()
.setQuery(query)
.setRecentlyBrowsedKeys(recentlyBrowsedKeys)
.map(ComponentHit::getUuid)
.collect(Collectors.toSet());
List<EntityDto> entities = dbClient.entityDao().selectByUuids(dbSession, entityUuids);
- Set<String> favoriteUuids = favorites.stream().map(EntityDto::getUuid).collect(MoreCollectors.toSet(favorites.size()));
+ Set<String> favoriteUuids = favorites.stream().map(EntityDto::getUuid).collect(Collectors.toSet());
SuggestionsWsResponse.Builder searchWsResponse = buildResponse(recentlyBrowsedKeys, favoriteUuids, componentsPerQualifiers, entities, skip + limit);
getWarning(query).ifPresent(searchWsResponse::setWarning);
return searchWsResponse.build();
import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.collect.Lists.newArrayList;
import static java.util.Collections.emptyList;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
/**
* Save issues into database. It is executed :
Collection<IssueDto> updated = update(issuesToUpdate, now);
doAfterSave(dbSession, Stream.concat(inserted.stream(), updated.stream())
- .collect(toSet(issuesToInsert.size() + issuesToUpdate.size())));
+ .collect(Collectors.toSet()));
return Stream.concat(inserted.stream(), updated.stream())
- .collect(toSet(issuesToInsert.size() + issuesToUpdate.size()));
+ .collect(Collectors.toSet());
}
private void doAfterSave(DbSession dbSession, Collection<IssueDto> issues) {
import static org.sonar.core.issue.IssueChangeContext.issueChangeContextByUserBuilder;
import static org.sonar.core.util.Uuids.UUID_EXAMPLE_01;
import static org.sonar.core.util.Uuids.UUID_EXAMPLE_02;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.server.es.SearchOptions.MAX_PAGE_SIZE;
import static org.sonar.server.issue.AbstractChangeTagsAction.TAGS_PARAMETER;
.filter(issue -> issue.updateDate() != null)
.map(issue -> toNotification(bulkChangeData, userDtoByUuid, issue))
.filter(Objects::nonNull)
- .collect(toSet(issues.size()));
+ .collect(Collectors.toSet());
if (changedIssues.isEmpty()) {
return;
// should not happen but filter it out anyway to avoid NPE in oldestUpdateDate call below
.filter(issue -> issue.updateDate() != null)
.filter(Objects::nonNull)
- .collect(toSet(issues.size()));
+ .collect(Collectors.toSet());
if (changedIssues.isEmpty()) {
return;
private List<IssueDto> loadIssues(SearchResponseData preloadedResponseData, Collector collector, DbSession dbSession) {
List<IssueDto> preloadedIssues = preloadedResponseData.getIssues();
- Set<String> preloadedIssueKeys = preloadedIssues.stream().map(IssueDto::getKey).collect(MoreCollectors.toSet(preloadedIssues.size()));
+ Set<String> preloadedIssueKeys = preloadedIssues.stream().map(IssueDto::getKey).collect(Collectors.toSet());
ImmutableSet<String> issueKeys = ImmutableSet.copyOf(collector.getIssueKeys());
Set<String> issueKeysToLoad = copyOf(difference(issueKeys, preloadedIssueKeys));
private void loadComponents(SearchResponseData preloadedResponseData, Collector collector, DbSession dbSession, SearchResponseData result) {
Collection<ComponentDto> preloadedComponents = preloadedResponseData.getComponents();
- Set<String> preloadedComponentUuids = preloadedComponents.stream().map(ComponentDto::uuid).collect(MoreCollectors.toSet(preloadedComponents.size()));
+ Set<String> preloadedComponentUuids = preloadedComponents.stream().map(ComponentDto::uuid).collect(Collectors.toSet());
Set<String> componentUuidsToLoad = copyOf(difference(collector.getComponentUuids(), preloadedComponentUuids));
result.addComponents(preloadedComponents);
Set<String> entityUuids = properties.stream()
.map(PropertyDto::getEntityUuid)
.filter(Objects::nonNull)
- .collect(MoreCollectors.toSet(properties.size()));
+ .collect(Collectors.toSet());
Set<String> authorizedProjectUuids = dbClient.authorizationDao().keepAuthorizedEntityUuids(dbSession, entityUuids, userSession.getUuid(), UserRole.USER);
return dbClient.entityDao().selectByUuids(dbSession, entityUuids)
.stream()
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 ImmutableSet.toImmutableSet();
}
- public static <T> Collector<T, ?, Set<T>> toSet(int expectedSize) {
- return Collectors.toSet();
- }
-
/**
* A Collector into an {@link EnumSet} of specified enumeration.
*/
import static org.sonar.core.util.stream.MoreCollectors.toHashSet;
import static org.sonar.core.util.stream.MoreCollectors.toImmutableList;
import static org.sonar.core.util.stream.MoreCollectors.toImmutableSet;
-import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.core.util.stream.MoreCollectors.unorderedFlattenIndex;
import static org.sonar.core.util.stream.MoreCollectors.unorderedIndex;
.containsExactly(1, 2, 3, 4, 5);
}
- @Test
- public void toSet_with_size_parallel_stream() {
- assertThat(HUGE_SET.parallelStream().collect(toSet(HUGE_SET.size()))).isEqualTo(HUGE_SET);
- }
-
@Test
public void toEnumSet() {
Set<MyEnum> res = Stream.of(MyEnum.ONE, MyEnum.ONE, MyEnum.TWO).collect(MoreCollectors.toEnumSet(MyEnum.class));
projects / sonarqube.git / commitdiff