typaram.getName().toString(), (TypeVariableSymbol) ASTHelpers.getSymbol(typaram)); SetView<String> difference = Sets.difference(annotation.containerOf(), typarams.keySet()); if (!difference.isEmpty()) { return buildDescription(tree) .setMessage( .filter( e -> annotation.containerOf().contains(e.getKey()) && analysis.hasThreadSafeTypeParameterAnnotation(e.getValue())) .map(Entry::getKey) .collect(toImmutableSet()); if (!immutableAndContainer.isEmpty()) { return buildDescription(tree) .setMessage( Optional.of(tree), immutableTypeParametersInScope(ASTHelpers.getSymbol(tree), state, analysis), ASTHelpers.getType(tree),
private static void checkIntersection( Sets.SetView<VersionlessDependency> intersect, String setA, String setB) { String intersectErrorString = intersect .stream() .map(VersionlessDependency::mavenCoords) .collect(Collectors.joining("\n")); Preconditions.checkArgument( intersect.size() == 0, String.format( "'%s' found in both '%s' & '%s', please remove from one of them.", intersectErrorString, setA, setB)); }
private static void verifyRuleKeyConsistency(List<RulesDefinition.ExtendedRepository> repositories, RegisterRulesContext registerRulesContext) { List<RulesDefinition.Rule> definedRules = repositories.stream() .flatMap(r -> r.rules().stream()) .collect(toList()); Set<RuleKey> definedRuleKeys = definedRules.stream() .map(r -> RuleKey.of(r.repository().key(), r.key())) .collect(toSet()); List<RuleKey> definedDeprecatedRuleKeys = definedRules.stream() .flatMap(r -> r.deprecatedRuleKeys().stream()) .collect(toList()); // Find duplicates in declared deprecated rule keys Set<RuleKey> duplicates = findDuplicates(definedDeprecatedRuleKeys); checkState(duplicates.isEmpty(), "The following deprecated rule keys are declared at least twice [%s]", lazyToString(() -> duplicates.stream().map(RuleKey::toString).collect(Collectors.joining(",")))); // Find rule keys that are both deprecated and used Set<RuleKey> intersection = intersection(new HashSet<>(definedRuleKeys), new HashSet<>(definedDeprecatedRuleKeys)).immutableCopy(); checkState(intersection.isEmpty(), "The following rule keys are declared both as deprecated and used key [%s]", lazyToString(() -> intersection.stream().map(RuleKey::toString).collect(Collectors.joining(",")))); // Find incorrect usage of deprecated keys ImmutableMap<RuleKey, SingleDeprecatedRuleKey> dbDeprecatedRuleKeysByOldRuleKey = registerRulesContext.getDbDeprecatedKeysByOldRuleKey(); Set<String> incorrectRuleKeyMessage = definedRules.stream() .flatMap(r -> filterInvalidDeprecatedRuleKeys(dbDeprecatedRuleKeysByOldRuleKey, r)) .filter(Objects::nonNull) .collect(Collectors.toSet()); checkState(incorrectRuleKeyMessage.isEmpty(), "An incorrect state of deprecated rule keys has been detected.\n %s", lazyToString(() -> incorrectRuleKeyMessage.stream().collect(Collectors.joining("\n")))); }
lastProjectPaths = lines .map(String::trim) .filter(s -> !Strings.isNullOrEmpty(s)) .collect(MoreCollectors.toImmutableSet()); lastProjectPaths = ImmutableSet.of(); okbuckState.getParentFile().mkdirs(); okbuckState.createNewFile(); .collect(MoreCollectors.toImmutableSet()); Sets.SetView<String> difference = Sets.difference(lastProjectPaths, currentProjectPaths); .stream() .map(p -> rootProjectPath.resolve(p).resolve(OkBuckGradlePlugin.BUCK)) .forEach(FileUtil::deleteQuietly);
if (targets.isEmpty()) { return Result.empty(); Map<Symbol, Expression> parentAssignments = parent.getAssignments() .entrySet().stream() .collect(Collectors.toMap( Map.Entry::getKey, entry -> inlineReferences(entry.getValue(), assignments))); .filter(entry -> targets.contains(entry.getKey())) .map(Map.Entry::getValue) .flatMap(entry -> SymbolsExtractor.extractAll(entry).stream()) .collect(toSet()); if (!targets.contains(assignment.getKey())) { childAssignments.put(assignment);
ImmutableSet<ImmutableExpression> functionFreeEqualities = expressions.stream() .filter(e -> e.getFunctionSymbol().equals(EQ)) .filter(e -> { ImmutableList<? extends ImmutableTerm> arguments = e.getTerms(); return arguments.stream().allMatch(t -> t instanceof NonFunctionalTerm); }) .collect(ImmutableCollectors.toSet()); ImmutableSubstitution<NonFunctionalTerm> normalizedUnifier = unify(functionFreeEqualities.stream() .map(ImmutableFunctionalTerm::getTerms) .map(args -> Maps.immutableEntry( (NonFunctionalTerm) args.get(0), (NonFunctionalTerm)args.get(1))), nonLiftableVariables); Stream.concat( expressions.stream() .filter(e -> !functionFreeEqualities.contains(e)) .map(normalizedUnifier::applyToBooleanExpression), Sets.difference(normalizedUnifier.getDomain(), nonLiftableVariables).immutableCopy()));
public Set<String> getWhiteListedSystemAddons() { Set<String> oldFeatureFlags = getEnabledUnicornFeatureKeys(); Set<String> newFeatureFlags = getAllVertigoFeatureKeys().entrySet().stream() .filter(Map.Entry::getValue) .map(Map.Entry::getKey) .collect(Collectors.toSet()); Set<String> allSystemAddonKeys = Sets.union(oldFeatureFlags, newFeatureFlags).stream() .filter(flag -> flag.startsWith(SYSTEM_ADDON_WHITELIST_PREFIX)) .map(flag -> flag.replaceFirst(SYSTEM_ADDON_WHITELIST_PREFIX, "")) .collect(Collectors.toSet()); return Sets.union(DEFAULT_SYSTEM_ADDONS, allSystemAddonKeys); }
/** * @param schemaConcepts entry {@link SchemaConcept} set * @return top non-meta {@link SchemaConcept}s from within the provided set */ public static <T extends SchemaConcept> Set<T> top(Set<T> schemaConcepts) { return schemaConcepts.stream() .filter(rt -> Sets.intersection(supers(rt), schemaConcepts).isEmpty()) .collect(toSet()); }
@Override public PlanNode visitLateralJoin(LateralJoinNode node, RewriteContext<Set<Symbol>> context) { PlanNode subquery = context.rewrite(node.getSubquery(), context.get()); // remove unused lateral nodes if (intersection(ImmutableSet.copyOf(subquery.getOutputSymbols()), context.get()).isEmpty() && isScalar(subquery)) { return context.rewrite(node.getInput(), context.get()); } // prune not used correlation symbols Set<Symbol> subquerySymbols = SymbolsExtractor.extractUnique(subquery); List<Symbol> newCorrelation = node.getCorrelation().stream() .filter(subquerySymbols::contains) .collect(toImmutableList()); Set<Symbol> inputContext = ImmutableSet.<Symbol>builder() .addAll(context.get()) .addAll(newCorrelation) .build(); PlanNode input = context.rewrite(node.getInput(), inputContext); // remove unused lateral nodes if (intersection(ImmutableSet.copyOf(input.getOutputSymbols()), inputContext).isEmpty() && isScalar(input)) { return subquery; } return new LateralJoinNode(node.getId(), input, subquery, newCorrelation, node.getType(), node.getOriginSubquery()); } }
.map(CaseTree::getExpression) .filter(IdentifierTree.class::isInstance) .map(p -> ((IdentifierTree) p).getName().toString()) .collect(toImmutableSet()); boolean unrecognized = false; SetView<String> setDifference = Sets.difference(ASTHelpers.enumValues(switchType), handledCases); if (!setDifference.isEmpty()) { if (setDifference.contains("UNRECOGNIZED") && setDifference.size() == 1) {
@SuppressWarnings("unused") @JsonProperty(FIELD_CHANGED_FIELDS) public Map<String, Object> changedFields() { return Sets.intersection(originalMessage().keySet(), decoratedMessage().keySet()) .stream() .filter(key -> !originalMessage().get(key).equals(decoratedMessage().get(key))) .collect(Collectors.toMap(Function.identity(), key -> originalMessage().get(key))); }
private List<MetricDto> searchMetrics(DbSession dbSession, SearchHistoryRequest request) { List<MetricDto> metrics = dbClient.metricDao().selectByKeys(dbSession, request.getMetrics()); if (request.getMetrics().size() > metrics.size()) { Set<String> requestedMetrics = request.getMetrics().stream().collect(MoreCollectors.toSet()); Set<String> foundMetrics = metrics.stream().map(MetricDto::getKey).collect(MoreCollectors.toSet()); Set<String> unfoundMetrics = Sets.difference(requestedMetrics, foundMetrics).immutableCopy(); throw new IllegalArgumentException(format("Metrics %s are not found", String.join(", ", unfoundMetrics))); } return metrics; }
private BulkUpdateAdminsResult validateUsersAndRolesForBulkUpdate(List<String> usersToRemove, List<String> rolesToRemove, Set<Admin> existingAdmins) { Set<CaseInsensitiveString> existingAdminNames = existingAdmins.stream().map(Admin::getName).collect(Collectors.toSet()); Sets.SetView<CaseInsensitiveString> invalidUsersToRemove = Sets.difference(caseInsensitive(usersToRemove), existingAdminNames); Sets.SetView<CaseInsensitiveString> invalidRolesToRemove = Sets.difference(caseInsensitive(rolesToRemove), existingAdminNames); BulkUpdateAdminsResult result = new BulkUpdateAdminsResult(); if (invalidUsersToRemove.size() > 0) { result.setNonExistentUsers(invalidUsersToRemove); result.unprocessableEntity("Update failed because some users or roles do not exist under super admins."); } if (invalidRolesToRemove.size() > 0) { result.setNonExistentRoles(invalidRolesToRemove); result.unprocessableEntity("Update failed because some users or roles do not exist under super admins."); } return result; }
throw new ConfigurationException("Duplicate system group detected"); } else { Set<MemberId> newMembers = Stream.concat(systemGroup.members().stream(), info.systemGroup.members().stream()) .filter(memberId -> membershipService.getMember(memberId) != null) .collect(Collectors.toSet()); if (!Sets.difference(newMembers, systemGroup.members()).isEmpty()) { systemGroup = new PartitionGroupMembership(systemGroup.group(), systemGroup.config(), ImmutableSet.copyOf(newMembers), true); post(new PartitionGroupMembershipEvent(MEMBERS_CHANGED, systemGroup)); LOGGER.debug("{} - Updated management group {} from {}", membershipService.getLocalMember().id(), systemGroup, info.memberId); Set<MemberId> newMembers = Stream.concat(oldMembership.members().stream(), newMembership.members().stream()) .filter(memberId -> membershipService.getMember(memberId) != null) .collect(Collectors.toSet()); if (!Sets.difference(newMembers, oldMembership.members()).isEmpty()) { PartitionGroupMembership newGroup = new PartitionGroupMembership(oldMembership.group(), oldMembership.config(), ImmutableSet.copyOf(newMembers), false); groups.put(oldMembership.group(), newGroup); post(new PartitionGroupMembershipEvent(MEMBERS_CHANGED, newGroup));
/** * Given a set of potentially overlapping sdk targetings generate set of disjoint sdk targetings * covering all of them. * * <p>Assumption: There are no sdk range gaps in targetings. */ private static ImmutableList<SdkVersionTargeting> generateAllSdkTargetings( ImmutableList<SdkVersionTargeting> sdkVersionTargetings) { sdkVersionTargetings.forEach( sdkVersionTargeting -> checkState(sdkVersionTargeting.getValueList().size() == 1)); ImmutableList<Integer> minSdkValues = sdkVersionTargetings .stream() .map(sdkVersionTargeting -> sdkVersionTargeting.getValue(0).getMin().getValue()) .distinct() .sorted() .collect(toImmutableList()); ImmutableSet<SdkVersion> sdkVersions = minSdkValues.stream().map(TargetingProtoUtils::sdkVersionFrom).collect(toImmutableSet()); return sdkVersions .stream() .map( sdkVersion -> sdkVersionTargeting( sdkVersion, Sets.difference(sdkVersions, ImmutableSet.of(sdkVersion)).immutableCopy())) .collect(toImmutableList()); }
private void pollWorkers() { AllNodes allNodes = getAllNodes(); Set<Node> aliveNodes = ImmutableSet.<Node>builder() .addAll(allNodes.getActiveNodes()) .addAll(allNodes.getShuttingDownNodes()) .build(); ImmutableSet<String> aliveNodeIds = aliveNodes.stream() .map(Node::getNodeIdentifier) .collect(toImmutableSet()); // Remove nodes that don't exist anymore // Make a copy to materialize the set difference Set<String> deadNodes = difference(nodeStates.keySet(), aliveNodeIds).immutableCopy(); nodeStates.keySet().removeAll(deadNodes); // Add new nodes for (Node node : aliveNodes) { nodeStates.putIfAbsent(node.getNodeIdentifier(), new RemoteNodeState(httpClient, uriBuilderFrom(node.getHttpUri()).appendPath("/v1/info/state").build())); } // Schedule refresh nodeStates.values().forEach(RemoteNodeState::asyncRefresh); // update indexes refreshNodesInternal(); }
@SuppressWarnings("unused") @JsonProperty(FIELD_ADDED_FIELDS) public Map<String, Object> addedFields() { return Sets.difference(decoratedMessage().keySet(), originalMessage().keySet()) .stream() .collect(Collectors.toMap(Function.identity(), key -> decoratedMessage().get(key))); }
private boolean isCoverageMeasuresAlreadyDefined(InputFile f) { Set<String> metricKeys = StreamSupport.stream(measureCache.byComponentKey(f.key()).spliterator(), false) .map(m -> m.metric().key()).collect(toSet()); Set<String> allCoverageMetricKeys = CoverageType.UNIT.allMetrics().stream().map(Metric::key).collect(toSet()); return !Sets.intersection(metricKeys, allCoverageMetricKeys).isEmpty(); }
@CheckReturnValue public BundleModule sanitize(BundleModule module) { // The maps index native files by their containing ABI directory (example key is "lib/x86"). ImmutableMultimap<ZipPath, ModuleEntry> libFilesByAbiDir = indexLibFilesByAbiDir(module); ImmutableMultimap<ZipPath, ModuleEntry> libFilesByAbiDirToKeep = discardAbiDirsWithTooFewFiles(libFilesByAbiDir); if (libFilesByAbiDirToKeep.size() == libFilesByAbiDir.size()) { // ABI directories are correct, nothing to do. return module; } logger.warning( String.format( "Native directories of module '%s' don't contain the same number of files." + " The following files were therefore discarded: %s", module.getName(), Sets.difference( ImmutableSet.copyOf(libFilesByAbiDir.values()), ImmutableSet.copyOf(libFilesByAbiDirToKeep.values())) .stream() .map(ModuleEntry::getPath) .map(ZipPath::toString) .sorted() .collect(toImmutableList()))); return sanitizedModule(module, libFilesByAbiDirToKeep); }
0, new PlanNodeId("test"), ImmutableList.of(BIGINT, DOUBLE), Ints.asList(1, 0), Ints.asList(0), ImmutableList.of(BIGINT), Optional.of(3), Optional.empty(), 10, joinCompiler); MaterializedResult actual = toMaterializedResult(driverContext.getSession(), ImmutableList.of(DOUBLE, BIGINT), pages); ImmutableSet<?> actualSet = ImmutableSet.copyOf(actual.getMaterializedRows()); ImmutableSet<?> expectedPartition1Set = ImmutableSet.copyOf(expectedPartition1.getMaterializedRows()); ImmutableSet<?> expectedPartition2Set = ImmutableSet.copyOf(expectedPartition2.getMaterializedRows()); ImmutableSet<?> expectedPartition3Set = ImmutableSet.copyOf(expectedPartition3.getMaterializedRows()); assertEquals(Sets.intersection(expectedPartition1Set, actualSet).size(), 3); assertEquals(Sets.intersection(expectedPartition2Set, actualSet).size(), 3); assertEquals(Sets.intersection(expectedPartition3Set, actualSet).size(), 2);