import java.util.Collection;
import java.util.List;
import java.util.Objects;
+import java.util.stream.Collectors;
import org.sonar.api.utils.System2;
import org.sonar.core.util.UuidFactory;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
import static java.util.Collections.singletonList;
-import static org.sonar.core.util.stream.MoreCollectors.toArrayList;
import static org.sonar.db.DatabaseUtils.executeLargeUpdates;
public class EsQueueDao implements Dao {
List<String> uuids = items.stream()
.map(EsQueueDto::getUuid)
.filter(Objects::nonNull)
- .collect(toArrayList(items.size()));
+ .collect(Collectors.toList());
executeLargeUpdates(uuids, mapper::delete);
}
import javax.annotation.Nullable;
import org.sonar.api.utils.System2;
import org.sonar.core.util.UuidFactory;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.Dao;
import org.sonar.db.DatabaseUtils;
import org.sonar.db.DbSession;
}
public List<QProfileDto> selectChildren(DbSession dbSession, Collection<QProfileDto> profiles) {
- List<String> uuids = profiles.stream().map(QProfileDto::getKee).collect(MoreCollectors.toArrayList(profiles.size()));
+ List<String> uuids = profiles.stream().map(QProfileDto::getKee).collect(Collectors.toList());
return DatabaseUtils.executeLargeInputs(uuids, chunk -> mapper(dbSession).selectChildren(chunk));
}
import java.util.List;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
private static ArrayList<EsQueueDto> createEsQueueDtosFromEntities(Collection<String> entityUuids) {
return entityUuids.stream()
.map(entityUuid -> EsQueueDto.create(TYPE_COMPONENT.format(), entityUuid, null, entityUuid))
- .collect(MoreCollectors.toArrayList(entityUuids.size()));
+ .collect(Collectors.toList());
}
@Override
import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.sonar.api.resources.Qualifiers;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.BranchDto;
private Collection<EsQueueDto> prepareForRecovery(DbSession dbSession, Collection<String> entityUuids) {
List<EsQueueDto> items = entityUuids.stream()
.map(entityUuid -> EsQueueDto.create(TYPE_PROJECT_MEASURES.format(), entityUuid, null, entityUuid))
- .collect(MoreCollectors.toArrayList(entityUuids.size()));
+ .collect(Collectors.toList());
return dbClient.esQueueDao().insert(dbSession, items);
}
public IndexingResult commitAndIndex(DbSession dbSession, Collection<String> projectUuids) {
List<EsQueueDto> items = projectUuids.stream()
.map(projectUuid -> EsQueueDto.create(TYPE_PROJECT_MEASURES.format(), projectUuid, null, projectUuid))
- .collect(MoreCollectors.toArrayList(projectUuids.size()));
+ .collect(Collectors.toList());
dbClient.esQueueDao().insert(dbSession, items);
dbSession.commit();
BulkIndexer bulkIndexer = createBulkIndexer(Size.REGULAR, listener);
bulkIndexer.start();
- List<String> projectUuids = items.stream().map(EsQueueDto::getDocId).collect(MoreCollectors.toArrayList(items.size()));
+ List<String> projectUuids = items.stream().map(EsQueueDto::getDocId).collect(Collectors.toList());
Iterator<String> it = projectUuids.iterator();
while (it.hasNext()) {
String projectUuid = it.next();
import java.util.Random;
import java.util.Set;
import java.util.function.Supplier;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.junit.Rule;
import org.junit.Test;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
-import static org.sonar.core.util.stream.MoreCollectors.toArrayList;
import static org.sonar.db.component.BranchType.BRANCH;
@RunWith(DataProviderRunner.class)
.setAnalysisUuid(snapshotUuid)
.setKey(entry.getKey())
.setValue(entry.getValue()))
- .collect(toArrayList(properties.size()));
+ .collect(Collectors.toList());
dbTester.getDbClient().analysisPropertiesDao().insert(dbTester.getSession(), analysisProperties);
dbTester.getSession().commit();
}
import com.google.common.collect.ImmutableSet;
import java.util.Set;
+import java.util.stream.Collectors;
import org.assertj.core.groups.Tuple;
import org.junit.Test;
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;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
.containsExactlyInAnyOrder(
deprecatedRuleKeys.stream().map(
r -> tuple(null, r.repository(), r.rule(), rule.repository().key(), rule.key(), RuleKey.of(r.repository(), r.rule())))
- .collect(MoreCollectors.toArrayList(deprecatedRuleKeys.size())).toArray(new Tuple[deprecatedRuleKeys.size()]));
+ .collect(Collectors.toList()).toArray(new Tuple[deprecatedRuleKeys.size()]));
}
@Test
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.web.UserRole;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.ComponentDto;
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.server.component.ws.MeasuresWsParameters.PARAM_METRIC_KEYS;
+import static org.sonar.server.component.ws.MeasuresWsParameters.PARAM_PROJECT_KEYS;
+import static org.sonar.server.exceptions.BadRequestException.checkRequest;
import static org.sonar.server.measure.ws.MeasureDtoToWsMeasure.updateMeasureBuilder;
import static org.sonar.server.measure.ws.MeasuresWsParametersBuilder.createMetricKeysParameter;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_002;
-import static org.sonar.server.exceptions.BadRequestException.checkRequest;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
-import static org.sonar.server.component.ws.MeasuresWsParameters.PARAM_METRIC_KEYS;
-import static org.sonar.server.component.ws.MeasuresWsParameters.PARAM_PROJECT_KEYS;
public class SearchAction implements MeasuresWsAction {
private List<LiveMeasureDto> searchMeasures() {
return dbClient.liveMeasureDao().selectByComponentUuidsAndMetricUuids(dbSession,
- projects.stream().map(ComponentDto::uuid).collect(MoreCollectors.toArrayList(projects.size())),
- metrics.stream().map(MetricDto::getUuid).collect(MoreCollectors.toArrayList(metrics.size())));
+ projects.stream().map(ComponentDto::uuid).collect(Collectors.toList()),
+ metrics.stream().map(MetricDto::getUuid).collect(Collectors.toList()));
}
private SearchWsResponse buildResponse() {
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
List<RuleActivation> activations = activeRules.stream()
.map(activeRule -> toRuleActivation(activeRule, rulesByRuleKey))
.filter(Objects::nonNull)
- .collect(MoreCollectors.toArrayList(activeRules.size()));
+ .collect(Collectors.toList());
return qProfileRules.activateAndCommit(dbSession, profile, activations);
}
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import org.sonar.api.rule.RuleKey;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
import static org.sonar.core.util.stream.MoreCollectors.index;
-import static org.sonar.core.util.stream.MoreCollectors.toArrayList;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.server.exceptions.BadRequestException.checkRequest;
}
Collection<QProfileDto> baseProfiles = profilesByUuid.values().stream()
.filter(p -> p.getRulesProfileUuid().equals(baseRulesProfile.getUuid()))
- .collect(toArrayList(profilesByUuid.size()));
+ .collect(Collectors.toList());
DescendantProfilesSupplier.Result result = descendantProfilesSupplier.get(baseProfiles, rulesByUuid.keySet());
register(result.profiles());
register(result.activeRules(), result.activeRuleParams());
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
.map(QProfileDto::getRulesProfileUuid)
.collect(MoreCollectors.toHashSet());
Collection<ActiveRuleDto> activeRules = db.activeRuleDao().selectByRulesAndRuleProfileUuids(dbSession, ruleUuids, ruleProfileUuids);
- List<String> activeRuleUuids = activeRules.stream().map(ActiveRuleDto::getUuid).collect(MoreCollectors.toArrayList(activeRules.size()));
+ List<String> activeRuleUuids = activeRules.stream().map(ActiveRuleDto::getUuid).collect(Collectors.toList());
List<ActiveRuleParamDto> activeRuleParams = db.activeRuleDao().selectParamsByActiveRuleUuids(dbSession, activeRuleUuids);
return new DescendantProfilesSupplier.Result(profiles, activeRules, activeRuleParams);
};
private void completeWithActiveRules(DbSession dbSession, RuleActivationContext.Builder builder, Collection<String> ruleUuids, Collection<String> ruleProfileUuids) {
Collection<ActiveRuleDto> activeRules = db.activeRuleDao().selectByRulesAndRuleProfileUuids(dbSession, ruleUuids, ruleProfileUuids);
builder.setActiveRules(activeRules);
- List<String> activeRuleUuids = activeRules.stream().map(ActiveRuleDto::getUuid).collect(MoreCollectors.toArrayList(activeRules.size()));
+ List<String> activeRuleUuids = activeRules.stream().map(ActiveRuleDto::getUuid).collect(Collectors.toList());
builder.setActiveRuleParams(db.activeRuleDao().selectParamsByActiveRuleUuids(dbSession, activeRuleUuids));
}
return Collectors.toCollection(() -> EnumSet.noneOf(enumClass));
}
- public static <T> Collector<T, ?, ArrayList<T>> toArrayList(int size) {
- return java.util.stream.Collectors.toCollection(() -> new ArrayList<>(size));
- }
-
public static <T> Collector<T, ?, HashSet<T>> toHashSet() {
return java.util.stream.Collectors.toCollection(HashSet::new);
}
import com.google.common.base.Joiner;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.SetMultimap;
-import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import static org.assertj.core.api.Assertions.entry;
import static org.sonar.core.util.stream.MoreCollectors.index;
import static org.sonar.core.util.stream.MoreCollectors.join;
-import static org.sonar.core.util.stream.MoreCollectors.toArrayList;
import static org.sonar.core.util.stream.MoreCollectors.toHashSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.core.util.stream.MoreCollectors.unorderedFlattenIndex;
.isEmpty();
}
- @Test
- public void toArrayList_with_size_builds_an_ArrayList() {
- List<Integer> res = Stream.of(1, 2, 3, 4, 5).collect(toArrayList(30));
- assertThat(res).isInstanceOf(ArrayList.class)
- .containsExactly(1, 2, 3, 4, 5);
- }
-
- @Test
- public void toArrayList_with_size_parallel_stream() {
- assertThat(HUGE_LIST.parallelStream().collect(toArrayList(HUGE_LIST.size()))).isEqualTo(HUGE_LIST);
- }
-
@Test
public void toHashSet_builds_an_HashSet() {
Set<Integer> res = Stream.of(1, 2, 3, 4, 5).collect(toHashSet());