public Authentication getAuthentication(String token) {
Claims claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody();
Collection<? extends GrantedAuthority> authorities =
Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split(","))
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
User principal = new User(claims.getSubject(), "", authorities);
return new UsernamePasswordAuthenticationToken(principal, "", authorities);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] numbers = sc.nextLine().split(" ");
String sort = sc.nextLine();
if (sort.equals("Ascending")) {
List<Integer> output =
Arrays.stream(numbers).map(Integer::parseInt).sorted().collect(Collectors.toList());
for (Object items : output) {
System.out.print(items + " ");
}
} else if (sort.equals("Descending")) {
List<Integer> output =
Arrays.stream(numbers)
.map(Integer::parseInt)
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
for (Object items : output) {
System.out.print(items + " ");
}
}
}
@Override
public Optional<Suggestion> requestPlayerSuggestion(Player player, Room room) {
char userWantsToMakeSuggestion = '\0';
while (userWantsToMakeSuggestion != 'Y' && userWantsToMakeSuggestion != 'N') {
this.out.println("Do you want to make an suggestion (Y/N)?");
this.out.println("Your cards are: " + player.cards);
userWantsToMakeSuggestion = this.scanner.next().charAt(0);
}
if (userWantsToMakeSuggestion == 'Y') {
this.out.printf("You suggest it was done in the %s, by: \n", room);
Stream<String> suspects =
Arrays.stream(CluedoCharacter.values()).map(CluedoCharacter::toString);
CluedoCharacter suspect = CluedoCharacter.values()[this.selectOptionFromList(suspects)];
this.out.println("with the ");
Stream<String> weapons = Arrays.stream(Weapon.values()).map(Weapon::toString);
Weapon weapon = Weapon.values()[this.selectOptionFromList(weapons)];
return Optional.of(new Suggestion(suspect, weapon, room));
} else {
return Optional.empty();
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String inputData = scanner.nextLine();
List<Team> championsLeague = new ArrayList<>();
while (!inputData.equals("stop")) {
String[] inputArgs = inputData.split("\\|+");
String firstTeamName = inputArgs[0].trim();
String secondTeamName = inputArgs[1].trim();
if (!championsLeague.stream().anyMatch(t -> t.name.equals(firstTeamName))) {
championsLeague.add(new Team(firstTeamName));
}
if (!championsLeague.stream().anyMatch(t -> t.name.equals(secondTeamName))) {
championsLeague.add(new Team(secondTeamName));
}
Integer[] firstMatchResult =
Arrays.stream(inputArgs[2].trim().split(":+"))
.map(Integer::parseInt)
.toArray(Integer[]::new);
Integer[] secondMatchResult =
Arrays.stream(inputArgs[3].trim().split(":+"))
.map(Integer::parseInt)
.toArray(Integer[]::new);
Integer firstTeamGoals = firstMatchResult[0] + secondMatchResult[1];
Integer secondTeamGoals = firstMatchResult[1] + secondMatchResult[0];
Team firstTeam =
championsLeague.stream().filter(t -> t.name.equals(firstTeamName)).findFirst().get();
Team secondTeam =
championsLeague.stream().filter(t -> t.name.equals(secondTeamName)).findFirst().get();
if (firstTeamGoals > secondTeamGoals) {
firstTeam.wins++;
} else if (secondTeamGoals > firstTeamGoals) {
secondTeam.wins++;
} else if (firstTeamGoals.equals(secondTeamGoals)) {
int firstTeamAwayGoals = secondMatchResult[1];
int secondTeamAwayGoals = firstMatchResult[1];
if (firstTeamAwayGoals > secondTeamAwayGoals) {
firstTeam.wins++;
} else {
secondTeam.wins++;
}
}
firstTeam.opponents.add(secondTeam);
secondTeam.opponents.add(firstTeam);
inputData = scanner.nextLine();
}
Collections.sort(championsLeague);
championsLeague.forEach(System.out::println);
}
@Test
public void testRemoveUnfinishedLeftovers_abort_multipleFolders() throws Throwable {
ColumnFamilyStore cfs = MockSchema.newCFS(KEYSPACE);
File origiFolder = new Directories(cfs.metadata).getDirectoryForNewSSTables();
File dataFolder1 = new File(origiFolder, "1");
File dataFolder2 = new File(origiFolder, "2");
Files.createDirectories(dataFolder1.toPath());
Files.createDirectories(dataFolder2.toPath());
SSTableReader[] sstables = {
sstable(dataFolder1, cfs, 0, 128),
sstable(dataFolder1, cfs, 1, 128),
sstable(dataFolder2, cfs, 2, 128),
sstable(dataFolder2, cfs, 3, 128)
};
LogTransaction log = new LogTransaction(OperationType.COMPACTION);
assertNotNull(log);
LogTransaction.SSTableTidier[] tidiers = {
log.obsoleted(sstables[0]), log.obsoleted(sstables[2])
};
log.trackNew(sstables[1]);
log.trackNew(sstables[3]);
Collection<File> logFiles = log.logFiles();
Assert.assertEquals(2, logFiles.size());
// fake an abort
log.txnFile().abort();
Arrays.stream(sstables).forEach(s -> s.selfRef().release());
// test listing
Assert.assertEquals(
sstables[1].getAllFilePaths().stream().map(File::new).collect(Collectors.toSet()),
getTemporaryFiles(dataFolder1));
Assert.assertEquals(
sstables[3].getAllFilePaths().stream().map(File::new).collect(Collectors.toSet()),
getTemporaryFiles(dataFolder2));
// normally called at startup
LogTransaction.removeUnfinishedLeftovers(Arrays.asList(dataFolder1, dataFolder2));
// old tables should be only table left
assertFiles(dataFolder1.getPath(), new HashSet<>(sstables[0].getAllFilePaths()));
assertFiles(dataFolder2.getPath(), new HashSet<>(sstables[2].getAllFilePaths()));
// complete the transaction to avoid LEAK errors
Arrays.stream(tidiers).forEach(LogTransaction.SSTableTidier::run);
assertNull(log.complete(null));
}
public static <T> List<T> createFromList(String raw, TypedOption<T> option) {
if (raw == null) {
return Collections.emptyList();
}
final String[] segments = raw.split(option.getListSeparator());
return Arrays.stream(segments).map(s -> create(s.trim(), option)).collect(Collectors.toList());
}
// helper method to test if required files are present in the runtime
public void testRuntime(RelativeFileSet runtime, String[] file) throws ConfigException {
if (runtime == null) {
return; // null runtime is ok (request to use system)
}
Pattern[] weave = Arrays.stream(file).map(Pattern::compile).toArray(Pattern[]::new);
if (!runtime
.getIncludedFiles()
.stream()
.anyMatch(s -> Arrays.stream(weave).anyMatch(pattern -> pattern.matcher(s).matches()))) {
throw new ConfigException(
MessageFormat.format(I18N.getString("error.jre-missing-file"), Arrays.toString(file)),
I18N.getString("error.jre-missing-file.advice"));
}
}
public static <T> LinkedList<T> create(T head, T... members) {
return Try.catchAndThrow(
() -> {
// At least 1 parameter is ensured with this function signature!
final List<T> args =
Stream.concat(Stream.of(head), Arrays.stream(members)).collect(Collectors.toList());
return TailCall.run(() -> build(new StackWindow<T>(args), null));
});
}
/**
* Deserialized string into inverted index entry
*
* @param serializedEntry String serialized form of inverted index
* @return Inverted Index entry
*/
public static InvertedIndex deserializeEntry(String serializedEntry) {
String term = serializedEntry.substring(0, serializedEntry.indexOf('[')).trim();
String entry = serializedEntry.substring(serializedEntry.indexOf('['));
entry = entry.replace('[', ' ').replace(']', ' ').trim();
String[] indices = entry.split(" ");
Map<String, Long> map =
Arrays.stream(indices)
.map(index -> index.split("="))
.collect(Collectors.toMap(tokens -> tokens[0], tokens -> Long.parseLong(tokens[1])));
return new InvertedIndex(term, map);
}
@Override
public Optional<Suggestion> requestPlayerAccusation(Player player) {
char userWantsToMakeAccusation = '\0';
while (userWantsToMakeAccusation != 'Y' && userWantsToMakeAccusation != 'N') {
this.out.println("Do you want to make an accusation (Y/N)?");
userWantsToMakeAccusation = this.scanner.next().charAt(0);
}
if (userWantsToMakeAccusation == 'Y') {
this.out.println("Choose your suspect:");
Stream<String> suspects =
Arrays.stream(CluedoCharacter.values())
.filter(e -> !player.cards.contains(e))
.map(CluedoCharacter::toString);
CluedoCharacter suspect = CluedoCharacter.values()[this.selectOptionFromList(suspects)];
this.out.println("Choose your weapon:");
Stream<String> weapons =
Arrays.stream(Weapon.values())
.filter(e -> !player.cards.contains(e))
.map(Weapon::toString);
Weapon weapon = Weapon.values()[this.selectOptionFromList(weapons)];
this.out.println("Choose your room:");
Stream<String> rooms =
Arrays.stream(Room.values()).filter(e -> !player.cards.contains(e)).map(Room::toString);
Room room = Room.values()[this.selectOptionFromList(rooms)];
return Optional.of(new Suggestion(suspect, weapon, room));
} else {
return Optional.empty();
}
}
/**
* Randomly initializes this GaussianMixture for a given number of terms.
*
* @param random a {@link java.util.Random} object.
* @param numTerms a number of terms.
*/
public void randomInitialization(Random random, int numTerms) {
this.coefficients = new double[numTerms];
this.terms = new ArrayList<>(numTerms);
for (int k = 0; k < numTerms; k++) {
this.coefficients[k] = random.nextDouble();
Normal aux = new Normal(this.var);
aux.setMean(5 * random.nextGaussian());
aux.setVariance(random.nextDouble());
this.terms.add(aux);
}
;
DoubleStream aux = Arrays.stream(this.coefficients);
double suma = aux.sum();
aux = Arrays.stream(this.coefficients);
this.coefficients = aux.map(x -> x / suma).toArray();
// System.out.println(coefficients);
// this.coefficients = this.coefficients / .map().sum();
}
@Test
public void testAbortMultipleFolders() throws Throwable {
ColumnFamilyStore cfs = MockSchema.newCFS(KEYSPACE);
File origiFolder = new Directories(cfs.metadata).getDirectoryForNewSSTables();
File dataFolder1 = new File(origiFolder, "1");
File dataFolder2 = new File(origiFolder, "2");
Files.createDirectories(dataFolder1.toPath());
Files.createDirectories(dataFolder2.toPath());
SSTableReader[] sstables = {
sstable(dataFolder1, cfs, 0, 128),
sstable(dataFolder1, cfs, 1, 128),
sstable(dataFolder2, cfs, 2, 128),
sstable(dataFolder2, cfs, 3, 128)
};
LogTransaction log = new LogTransaction(OperationType.COMPACTION);
assertNotNull(log);
LogTransaction.SSTableTidier[] tidiers = {
log.obsoleted(sstables[0]), log.obsoleted(sstables[2])
};
log.trackNew(sstables[1]);
log.trackNew(sstables[3]);
Arrays.stream(tidiers).forEach(LogTransaction.SSTableTidier::abort);
log.abort();
Arrays.stream(sstables).forEach(s -> s.selfRef().release());
LogTransaction.waitForDeletions();
assertFiles(dataFolder1.getPath(), new HashSet<>(sstables[0].getAllFilePaths()));
assertFiles(dataFolder2.getPath(), new HashSet<>(sstables[2].getAllFilePaths()));
}
private ResourcesDef readResourcesDefinition(Element resourcesElement) {
String name = resourcesElement.getAttribute("name");
Assert.ifEmpty(name, "can`t read resources bundle without name");
ResourcesDef resDef = new ResourcesDef(name);
String depends = resourcesElement.getAttribute("depends");
if (isNoneEmpty(depends)) {
resDef.setDepends(
Arrays.stream(StringUtils.split(depends, ","))
.map(StringUtils::trim)
.collect(Collectors.toList()));
}
readResources(resourcesElement, resDef);
return resDef;
}
public static Map<String, Set<String>> getSelectedReleaseAndAttachmentIdsFromRequest(
ResourceRequest request) {
Map<String, Set<String>> releaseIdToAttachmentIds = new HashMap<>();
String[] checkboxes =
request.getParameterValues(PortalConstants.LICENSE_INFO_RELEASE_TO_ATTACHMENT);
Arrays.stream(checkboxes)
.forEach(
s -> {
String[] split = s.split(":");
if (split.length == 2) {
String releaseId = split[0];
String attachmentId = split[1];
if (!releaseIdToAttachmentIds.containsKey(releaseId)) {
releaseIdToAttachmentIds.put(releaseId, new HashSet<>());
}
releaseIdToAttachmentIds.get(releaseId).add(attachmentId);
}
});
return releaseIdToAttachmentIds;
}
public static void main(String... args) {
List<Integer> numbers = Arrays.asList(3, 4, 5, 1, 2);
Arrays.stream(numbers.toArray()).forEach(System.out::println);
int calories = Dish.menu.stream().mapToInt(Dish::getCalories).sum();
System.out.println("Number of calories:" + calories);
// max and OptionalInt
OptionalInt maxCalories = Dish.menu.stream().mapToInt(Dish::getCalories).max();
int max;
if (maxCalories.isPresent()) {
max = maxCalories.getAsInt();
} else {
// we can choose a default value
max = 1;
}
System.out.println(max);
// numeric ranges
IntStream evenNumbers = IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0);
System.out.println(evenNumbers.count());
Stream<int[]> pythagoreanTriples =
IntStream.rangeClosed(1, 100)
.boxed()
.flatMap(
a ->
IntStream.rangeClosed(a, 100)
.filter(b -> Math.sqrt(a * a + b * b) % 1 == 0)
.boxed()
.map(b -> new int[] {a, b, (int) Math.sqrt(a * a + b * b)}));
pythagoreanTriples.forEach(t -> System.out.println(t[0] + ", " + t[1] + ", " + t[2]));
}
/**
* get document and their corresponding length
*
* @param stemmedFile String stemmed file path
* @return Map of Document -> Length
* @throws IOException
*/
private static Map<String, Long> getDocumentAndLength(String stemmedFile) throws IOException {
HashMap<String, Long> documentLength = new HashMap<>();
Stream<String> stemmed = FileUtils.readFiles(stemmedFile);
Iterator<String> reader = stemmed.iterator();
String lastDocId = null;
while (reader.hasNext()) {
String line = reader.next();
if (isDocument(line)) {
lastDocId = line.replace('#', ' ').trim();
documentLength.put(lastDocId, 0L);
} else {
long length =
Arrays.stream(line.split(SEPARATOR_SPACE)).filter(Indexer::isNotNumber).count();
if (documentLength.containsKey(lastDocId)) {
documentLength.put(lastDocId, documentLength.get(lastDocId) + length);
} else {
documentLength.put(lastDocId, length);
}
}
}
return documentLength;
}
/**
* get all terms
*
* @param line String line
* @return list of term
*/
private static List<String> getAllTerms(String line) {
return Arrays.stream(line.split(SEPARATOR_SPACE))
.filter(Indexer::isNotNumber)
.collect(Collectors.toList());
}
private static void testRemoveUnfinishedLeftovers_multipleFolders_errorConditions(
Consumer<LogTransaction> modifier, boolean shouldCommit) throws Throwable {
ColumnFamilyStore cfs = MockSchema.newCFS(KEYSPACE);
File origiFolder = new Directories(cfs.metadata).getDirectoryForNewSSTables();
File dataFolder1 = new File(origiFolder, "1");
File dataFolder2 = new File(origiFolder, "2");
Files.createDirectories(dataFolder1.toPath());
Files.createDirectories(dataFolder2.toPath());
SSTableReader[] sstables = {
sstable(dataFolder1, cfs, 0, 128),
sstable(dataFolder1, cfs, 1, 128),
sstable(dataFolder2, cfs, 2, 128),
sstable(dataFolder2, cfs, 3, 128)
};
LogTransaction log = new LogTransaction(OperationType.COMPACTION);
assertNotNull(log);
LogTransaction.SSTableTidier[] tidiers = {
log.obsoleted(sstables[0]), log.obsoleted(sstables[2])
};
log.trackNew(sstables[1]);
log.trackNew(sstables[3]);
// fake some error condition on the txn logs
modifier.accept(log);
Arrays.stream(sstables).forEach(s -> s.selfRef().release());
LogTransaction.removeUnfinishedLeftovers(Arrays.asList(dataFolder1, dataFolder2));
LogTransaction.waitForDeletions();
if (shouldCommit) {
// only new sstables should still be there
assertFiles(dataFolder1.getPath(), new HashSet<>(sstables[1].getAllFilePaths()));
assertFiles(dataFolder2.getPath(), new HashSet<>(sstables[3].getAllFilePaths()));
} else {
// all files should still be there
assertFiles(
dataFolder1.getPath(),
Sets.newHashSet(
Iterables.concat(
sstables[0].getAllFilePaths(),
sstables[1].getAllFilePaths(),
Collections.singleton(log.logFilePaths().get(0)))));
assertFiles(
dataFolder2.getPath(),
Sets.newHashSet(
Iterables.concat(
sstables[2].getAllFilePaths(),
sstables[3].getAllFilePaths(),
Collections.singleton(log.logFilePaths().get(1)))));
}
// complete the transaction to avoid LEAK errors
Arrays.stream(tidiers).forEach(LogTransaction.SSTableTidier::run);
log.txnFile().commit(); // just anything to make sure transaction tidier will finish
assertNull(log.complete(null));
}
/**
* Given arguments specifying an SSTable, and optionally an output file, export the contents of
* the SSTable to JSON.
*
* @param args command lines arguments
* @throws ConfigurationException on configuration failure (wrong params given)
*/
public static void main(String[] args) throws ConfigurationException {
CommandLineParser parser = new PosixParser();
try {
cmd = parser.parse(options, args);
} catch (ParseException e1) {
System.err.println(e1.getMessage());
printUsage();
System.exit(1);
}
if (cmd.getArgs().length != 1) {
System.err.println("You must supply exactly one sstable");
printUsage();
System.exit(1);
}
String[] keys = cmd.getOptionValues(KEY_OPTION);
HashSet<String> excludes =
new HashSet<>(
Arrays.asList(
cmd.getOptionValues(EXCLUDE_KEY_OPTION) == null
? new String[0]
: cmd.getOptionValues(EXCLUDE_KEY_OPTION)));
String ssTableFileName = new File(cmd.getArgs()[0]).getAbsolutePath();
if (Descriptor.isLegacyFile(new File(ssTableFileName))) {
System.err.println("Unsupported legacy sstable");
System.exit(1);
}
if (!new File(ssTableFileName).exists()) {
System.err.println("Cannot find file " + ssTableFileName);
System.exit(1);
}
Descriptor desc = Descriptor.fromFilename(ssTableFileName);
try {
CFMetaData metadata = metadataFromSSTable(desc);
if (cmd.hasOption(ENUMERATE_KEYS_OPTION)) {
JsonTransformer.keysToJson(
null,
iterToStream(new KeyIterator(desc, metadata)),
cmd.hasOption(RAW_TIMESTAMPS),
metadata,
System.out);
} else {
SSTableReader sstable = SSTableReader.openNoValidation(desc, metadata);
IPartitioner partitioner = sstable.getPartitioner();
final ISSTableScanner currentScanner;
if ((keys != null) && (keys.length > 0)) {
List<AbstractBounds<PartitionPosition>> bounds =
Arrays.stream(keys)
.filter(key -> !excludes.contains(key))
.map(metadata.getKeyValidator()::fromString)
.map(partitioner::decorateKey)
.sorted()
.map(DecoratedKey::getToken)
.map(token -> new Bounds<>(token.minKeyBound(), token.maxKeyBound()))
.collect(Collectors.toList());
currentScanner = sstable.getScanner(bounds.iterator());
} else {
currentScanner = sstable.getScanner();
}
Stream<UnfilteredRowIterator> partitions =
iterToStream(currentScanner)
.filter(
i ->
excludes.isEmpty()
|| !excludes.contains(
metadata.getKeyValidator().getString(i.partitionKey().getKey())));
if (cmd.hasOption(DEBUG_OUTPUT_OPTION)) {
AtomicLong position = new AtomicLong();
partitions.forEach(
partition -> {
position.set(currentScanner.getCurrentPosition());
if (!partition.partitionLevelDeletion().isLive()) {
System.out.println(
"["
+ metadata.getKeyValidator().getString(partition.partitionKey().getKey())
+ "]@"
+ position.get()
+ " "
+ partition.partitionLevelDeletion());
}
if (!partition.staticRow().isEmpty()) {
System.out.println(
"["
+ metadata.getKeyValidator().getString(partition.partitionKey().getKey())
+ "]@"
+ position.get()
+ " "
+ partition.staticRow().toString(metadata, true));
}
partition.forEachRemaining(
row -> {
System.out.println(
"["
+ metadata
.getKeyValidator()
.getString(partition.partitionKey().getKey())
+ "]@"
+ position.get()
+ " "
+ row.toString(metadata, false, true));
position.set(currentScanner.getCurrentPosition());
});
});
} else {
JsonTransformer.toJson(
currentScanner, partitions, cmd.hasOption(RAW_TIMESTAMPS), metadata, System.out);
}
}
} catch (IOException e) {
// throwing exception outside main with broken pipe causes windows cmd to hang
e.printStackTrace(System.err);
}
System.exit(0);
}
@Test
public void testGetTemporaryFilesMultipleFolders() throws IOException {
ColumnFamilyStore cfs = MockSchema.newCFS(KEYSPACE);
File origiFolder = new Directories(cfs.metadata).getDirectoryForNewSSTables();
File dataFolder1 = new File(origiFolder, "1");
File dataFolder2 = new File(origiFolder, "2");
Files.createDirectories(dataFolder1.toPath());
Files.createDirectories(dataFolder2.toPath());
SSTableReader[] sstables = {
sstable(dataFolder1, cfs, 0, 128),
sstable(dataFolder1, cfs, 1, 128),
sstable(dataFolder2, cfs, 2, 128),
sstable(dataFolder2, cfs, 3, 128)
};
// they should all have the same number of files since they are created in the same way
int numSStableFiles = sstables[0].getAllFilePaths().size();
LogTransaction log = new LogTransaction(OperationType.COMPACTION);
assertNotNull(log);
for (File dataFolder : new File[] {dataFolder1, dataFolder2}) {
Set<File> tmpFiles = getTemporaryFiles(dataFolder);
assertNotNull(tmpFiles);
assertEquals(0, tmpFiles.size());
}
LogTransaction.SSTableTidier[] tidiers = {
log.obsoleted(sstables[0]), log.obsoleted(sstables[2])
};
log.trackNew(sstables[1]);
log.trackNew(sstables[3]);
for (File dataFolder : new File[] {dataFolder1, dataFolder2}) {
Set<File> tmpFiles = getTemporaryFiles(dataFolder);
assertNotNull(tmpFiles);
assertEquals(numSStableFiles, tmpFiles.size());
}
log.finish();
for (File dataFolder : new File[] {dataFolder1, dataFolder2}) {
Set<File> tmpFiles = getTemporaryFiles(dataFolder);
assertNotNull(tmpFiles);
assertEquals(numSStableFiles, tmpFiles.size());
}
sstables[0].markObsolete(tidiers[0]);
sstables[2].markObsolete(tidiers[1]);
Arrays.stream(sstables).forEach(s -> s.selfRef().release());
LogTransaction.waitForDeletions();
for (File dataFolder : new File[] {dataFolder1, dataFolder2}) {
Set<File> tmpFiles = getTemporaryFiles(dataFolder);
assertNotNull(tmpFiles);
assertEquals(0, tmpFiles.size());
}
}
@Override
protected boolean preprocessUsages(@NotNull Ref<UsageInfo[]> refUsages) {
UsageInfo[] usages = refUsages.get();
ArrayList<String> conflicts = new ArrayList<String>();
for (PsiElement element : myElements) {
for (SafeDeleteProcessorDelegate delegate :
Extensions.getExtensions(SafeDeleteProcessorDelegate.EP_NAME)) {
if (delegate.handlesElement(element)) {
Collection<String> foundConflicts =
delegate instanceof SafeDeleteProcessorDelegateBase
? ((SafeDeleteProcessorDelegateBase) delegate)
.findConflicts(element, myElements, usages)
: delegate.findConflicts(element, myElements);
if (foundConflicts != null) {
conflicts.addAll(foundConflicts);
}
break;
}
}
}
final HashMap<PsiElement, UsageHolder> elementsToUsageHolders = sortUsages(usages);
final Collection<UsageHolder> usageHolders = elementsToUsageHolders.values();
for (UsageHolder usageHolder : usageHolders) {
if (usageHolder.hasUnsafeUsagesInCode()) {
conflicts.add(usageHolder.getDescription());
}
}
if (!conflicts.isEmpty()) {
final RefactoringEventData conflictData = new RefactoringEventData();
conflictData.putUserData(RefactoringEventData.CONFLICTS_KEY, conflicts);
myProject
.getMessageBus()
.syncPublisher(RefactoringEventListener.REFACTORING_EVENT_TOPIC)
.conflictsDetected("refactoring.safeDelete", conflictData);
if (ApplicationManager.getApplication().isUnitTestMode()) {
if (!ConflictsInTestsException.isTestIgnore())
throw new ConflictsInTestsException(conflicts);
} else {
UnsafeUsagesDialog dialog =
new UnsafeUsagesDialog(ArrayUtil.toStringArray(conflicts), myProject);
if (!dialog.showAndGet()) {
final int exitCode = dialog.getExitCode();
prepareSuccessful(); // dialog is always dismissed;
if (exitCode == UnsafeUsagesDialog.VIEW_USAGES_EXIT_CODE) {
showUsages(
Arrays.stream(usages)
.filter(
usage ->
usage instanceof SafeDeleteReferenceUsageInfo
&& !((SafeDeleteReferenceUsageInfo) usage).isSafeDelete())
.toArray(UsageInfo[]::new));
}
return false;
} else {
myPreviewNonCodeUsages = false;
}
}
}
UsageInfo[] preprocessedUsages = usages;
for (SafeDeleteProcessorDelegate delegate :
Extensions.getExtensions(SafeDeleteProcessorDelegate.EP_NAME)) {
preprocessedUsages = delegate.preprocessUsages(myProject, preprocessedUsages);
if (preprocessedUsages == null) return false;
}
final UsageInfo[] filteredUsages = UsageViewUtil.removeDuplicatedUsages(preprocessedUsages);
prepareSuccessful(); // dialog is always dismissed
if (filteredUsages == null) {
return false;
}
refUsages.set(filteredUsages);
return true;
}
@Override
public Map<Long, Long> findFS() {
int[] usedCounts = Arrays.copyOfRange(counts, 0, capwidth);
// initial frequency is the same as what we see from counters
Map<Integer, Long> freq =
Arrays.stream(usedCounts)
.boxed()
.collect(Collectors.groupingBy(Integer::intValue, Collectors.counting()));
Long zeroNum = freq.get(0);
if (zeroNum != null && zeroNum == capwidth) {
return new HashMap<>();
}
// estimate the number of items
int num = (int) (capwidth * Math.log(1.0 * capwidth / zeroNum));
Distribution newDistribution = new Distribution(freq);
Distribution oldDistribution = new Distribution();
// A pattern is a setting of itmes+frequencies that sum to sumI
// All patterns in this list will map to a common number sumI
List<Map<Integer, Integer>> patterns = new ArrayList<>();
List<Double> probabilities = new ArrayList<>();
int iterations = 0;
// iteratively update the distribution
// while (notConverged()) {
while (iterations < MAXIMUM_ITERATIONS) {
oldDistribution.fillFrom(newDistribution);
newDistribution.clear();
for (Map.Entry<Integer, Long> entry : freq.entrySet()) {
int sumI = entry.getKey();
int freqI = entry.getValue().intValue();
if (sumI == 0) { // skip key=0
continue;
}
// find new probable patterns, get their probabilities and update the distribution
getPatterns(patterns, sumI, freqI, oldDistribution);
computeProbabilities(patterns, oldDistribution, probabilities);
Iterator<Double> probabilityIterator = probabilities.iterator();
for (Map<Integer, Integer> pattern : patterns) { // for each pattern
double probability = probabilityIterator.next();
for (Map.Entry<Integer, Integer> patternEntry : pattern.entrySet()) {
newDistribution.addFreq(
patternEntry.getKey(), freqI * patternEntry.getValue() * probability);
}
}
}
// scale factor to make sum of distribution equal to 1
double scale = num / newDistribution.sumFreq();
pw.println(
String.format(
DISTRIBUTION_TRACE_FORMATTER,
getStep() + 1,
iterations + 1,
newDistribution.toString(scale)));
iterations++;
}
pw.flush();
System.out.println(getStep());
Map<Long, Long> output = new HashMap<>();
double freqSum = newDistribution.sumFreq();
for (Map.Entry<Integer, Double> entry : newDistribution.freq.entrySet()) {
output.put(entry.getKey().longValue(), (long) (entry.getValue() / freqSum * num));
}
return output;
}
public Set<String> getTopics() {
if (topicsString == null || topicsString.isEmpty()) return new HashSet<>();
return Arrays.stream(topicsString.split(",")).map(String::trim).collect(Collectors.toSet());
}
