Example usage for com.google.common.collect Sets intersection

List of usage examples for com.google.common.collect Sets intersection

Introduction

In this page you can find the example usage for com.google.common.collect Sets intersection.

Prototype

public static <E> SetView<E> intersection(final Set<E> set1, final Set<?> set2) 

Source Link

Document

Returns an unmodifiable view of the intersection of two sets.

Usage

From source file:org.geogit.api.plumbing.diff.DiffCounter.java

private DiffObjectCount countBucketsChildren(ImmutableSortedMap<Integer, Bucket> buckets,
        Iterator<Node> children, final NodeStorageOrder refOrder, final int depth) {

    final SortedSetMultimap<Integer, Node> treesByBucket;
    final SortedSetMultimap<Integer, Node> featuresByBucket;
    {/*from w ww  .j  a v  a 2s.  c o m*/
        treesByBucket = TreeMultimap.create(Ordering.natural(), refOrder); // make sure values
                                                                           // are sorted
                                                                           // according to
                                                                           // refOrder
        featuresByBucket = TreeMultimap.create(Ordering.natural(), refOrder);// make sure values
                                                                             // are sorted
                                                                             // according to
                                                                             // refOrder
        while (children.hasNext()) {
            Node ref = children.next();
            Integer bucket = refOrder.bucket(ref, depth);
            if (ref.getType().equals(TYPE.TREE)) {
                treesByBucket.put(bucket, ref);
            } else {
                featuresByBucket.put(bucket, ref);
            }
        }
    }

    DiffObjectCount count = new DiffObjectCount();

    {// count full size of all buckets for which no children falls into
        final Set<Integer> loneleyBuckets = Sets.difference(buckets.keySet(),
                Sets.union(featuresByBucket.keySet(), treesByBucket.keySet()));

        for (Integer bucket : loneleyBuckets) {
            ObjectId bucketId = buckets.get(bucket).id();
            count.add(sizeOfTree(bucketId));
        }
    }
    {// count the full size of all children whose buckets don't exist on the buckets tree
        for (Integer bucket : Sets.difference(featuresByBucket.keySet(), buckets.keySet())) {
            SortedSet<Node> refs = featuresByBucket.get(bucket);
            count.addFeatures(refs.size());
        }

        for (Integer bucket : Sets.difference(treesByBucket.keySet(), buckets.keySet())) {
            SortedSet<Node> refs = treesByBucket.get(bucket);
            count.add(aggregateSize(refs));
        }
    }

    // find the number of diffs of the intersection
    final Set<Integer> commonBuckets = Sets.intersection(buckets.keySet(),
            Sets.union(featuresByBucket.keySet(), treesByBucket.keySet()));
    for (Integer bucket : commonBuckets) {

        Iterator<Node> refs = Iterators.concat(treesByBucket.get(bucket).iterator(),
                featuresByBucket.get(bucket).iterator());

        final ObjectId bucketId = buckets.get(bucket).id();
        final RevTree bucketTree = getTree(bucketId);

        if (bucketTree.isEmpty()) {
            // unlikely
            count.add(aggregateSize(refs));
        } else if (!bucketTree.buckets().isPresent()) {
            count.add(countChildrenDiffs(bucketTree.children(), refs));
        } else {
            final int deeperBucketsDepth = depth + 1;
            final ImmutableSortedMap<Integer, Bucket> deeperBuckets;
            deeperBuckets = bucketTree.buckets().get();
            count.add(countBucketsChildren(deeperBuckets, refs, refOrder, deeperBucketsDepth));
        }
    }

    return count;
}

From source file:org.sosy_lab.cpachecker.cpa.reachdef.ReachingDefState.java

private boolean isSubsetOf(Map<String, Set<DefinitionPoint>> subset,
        Map<String, Set<DefinitionPoint>> superset) {
    Set<DefinitionPoint> setSub, setSuper;
    if (subset == superset) {
        return true;
    }//from  w w  w .  j  a  v a  2  s.  c  o m
    for (Entry<String, Set<DefinitionPoint>> entry : subset.entrySet()) {
        setSub = entry.getValue();
        setSuper = superset.get(entry.getKey());
        if (setSub == setSuper) {
            continue;
        }
        if (setSuper == null || Sets.intersection(setSub, setSuper).size() != setSub.size()) {
            return false;
        }
    }
    return true;
}

From source file:com.facebook.buck.apple.xcode.WorkspaceAndProjectGenerator.java

public Path generateWorkspaceAndDependentProjects(Map<TargetNode<?>, ProjectGenerator> projectGenerators)
        throws IOException {
    LOG.debug("Generating workspace for target %s", workspaceTargetNode);

    String workspaceName;/*from w ww .  j a  va  2  s  .c om*/
    Path outputDirectory;

    if (combinedProject) {
        workspaceName = "GeneratedProject";
        outputDirectory = Paths.get("_gen");
    } else {
        workspaceName = XcodeWorkspaceConfigDescription
                .getWorkspaceNameFromArg(workspaceTargetNode.getConstructorArg());
        outputDirectory = workspaceTargetNode.getBuildTarget().getBasePath();
    }

    WorkspaceGenerator workspaceGenerator = new WorkspaceGenerator(projectFilesystem, workspaceName,
            outputDirectory);

    ImmutableSet<TargetNode<?>> orderedTargetNodes;
    if (workspaceTargetNode.getConstructorArg().srcTarget.isPresent()) {
        orderedTargetNodes = AppleBuildRules.getSchemeBuildableTargetNodes(projectGraph,
                projectGraph.get(workspaceTargetNode.getConstructorArg().srcTarget.get().getBuildTarget()));
    } else {
        orderedTargetNodes = ImmutableSet.of();
    }

    ImmutableSet<TargetNode<?>> orderedTestTargetNodes;
    ImmutableSet<TargetNode<?>> orderedTestBundleTargetNodes;
    {
        ImmutableSet.Builder<TargetNode<?>> orderedTestTargetNodesBuilder = ImmutableSet.builder();
        ImmutableSet.Builder<TargetNode<?>> orderedTestBundleTargetNodesBuilder = ImmutableSet.builder();

        getOrderedTestNodes(projectGraph, sourceTargetToTestNodes, orderedTargetNodes,
                extraTestBundleTargetNodes, orderedTestTargetNodesBuilder, orderedTestBundleTargetNodesBuilder);

        orderedTestTargetNodes = orderedTestTargetNodesBuilder.build();
        orderedTestBundleTargetNodes = orderedTestBundleTargetNodesBuilder.build();
    }

    ImmutableSet<BuildTarget> targetsInRequiredProjects = FluentIterable
            .from(Sets.union(orderedTargetNodes, orderedTestTargetNodes)).transform(HasBuildTarget.TO_TARGET)
            .toSet();
    ImmutableMap.Builder<BuildTarget, PBXTarget> buildTargetToPbxTargetMapBuilder = ImmutableMap.builder();
    ImmutableMap.Builder<PBXTarget, Path> targetToProjectPathMapBuilder = ImmutableMap.builder();

    if (combinedProject) {
        ImmutableSet.Builder<BuildTarget> initialTargetsBuilder = ImmutableSet.builder();
        for (TargetNode<?> targetNode : projectGraph.getNodes()) {
            if (targetNode.getType() != XcodeProjectConfigDescription.TYPE) {
                continue;
            }
            XcodeProjectConfigDescription.Arg projectArg = (XcodeProjectConfigDescription.Arg) targetNode
                    .getConstructorArg();
            if (Sets.intersection(targetsInRequiredProjects, projectArg.rules).isEmpty()) {
                continue;
            }
            initialTargetsBuilder.addAll(projectArg.rules);
        }

        LOG.debug("Generating a combined project");
        ProjectGenerator generator = new ProjectGenerator(projectGraph, initialTargetsBuilder.build(),
                projectFilesystem, executionContext, buildRuleResolver, sourcePathResolver, outputDirectory,
                "GeneratedProject", projectGeneratorOptions);
        combinedProjectGenerator = Optional.of(generator);
        generator.createXcodeProjects();

        workspaceGenerator.addFilePath(generator.getProjectPath());

        buildTargetToPbxTargetMapBuilder.putAll(generator.getBuildTargetToGeneratedTargetMap());
        for (PBXTarget target : generator.getBuildTargetToGeneratedTargetMap().values()) {
            targetToProjectPathMapBuilder.put(target, generator.getProjectPath());
        }
    } else {
        for (TargetNode<?> targetNode : projectGraph.getNodes()) {
            if (targetNode.getType() != XcodeProjectConfigDescription.TYPE) {
                continue;
            }
            XcodeProjectConfigDescription.Arg projectArg = (XcodeProjectConfigDescription.Arg) targetNode
                    .getConstructorArg();
            if (Sets.intersection(targetsInRequiredProjects, projectArg.rules).isEmpty()) {
                continue;
            }

            ProjectGenerator generator = projectGenerators.get(targetNode);
            if (generator == null) {
                LOG.debug("Generating project for target %s", targetNode);
                generator = new ProjectGenerator(projectGraph, projectArg.rules, projectFilesystem,
                        executionContext, buildRuleResolver, sourcePathResolver,
                        targetNode.getBuildTarget().getBasePath(), projectArg.projectName,
                        projectGeneratorOptions);
                generator.createXcodeProjects();
                projectGenerators.put(targetNode, generator);
            } else {
                LOG.debug("Already generated project for target %s, skipping", targetNode);
            }

            workspaceGenerator.addFilePath(generator.getProjectPath());

            buildTargetToPbxTargetMapBuilder.putAll(generator.getBuildTargetToGeneratedTargetMap());
            for (PBXTarget target : generator.getBuildTargetToGeneratedTargetMap().values()) {
                targetToProjectPathMapBuilder.put(target, generator.getProjectPath());
            }
        }
    }

    Path workspacePath = workspaceGenerator.writeWorkspace();

    SchemeGenerator schemeGenerator = new SchemeGenerator(projectFilesystem,
            workspaceTargetNode.getConstructorArg().srcTarget,
            Iterables.transform(orderedTargetNodes, HasBuildTarget.TO_TARGET),
            Iterables.transform(orderedTestTargetNodes, HasBuildTarget.TO_TARGET),
            Iterables.transform(orderedTestBundleTargetNodes, HasBuildTarget.TO_TARGET), workspaceName,
            outputDirectory.resolve(workspaceName + ".xcworkspace"),
            XcodeWorkspaceConfigDescription
                    .getActionConfigNamesFromArg(workspaceTargetNode.getConstructorArg()),
            buildTargetToPbxTargetMapBuilder.build(), targetToProjectPathMapBuilder.build());
    schemeGenerator.writeScheme();

    return workspacePath;
}

From source file:org.wso2.carbon.mss.internal.router.HttpResourceModel.java

/**
 * Gathers all parameters' annotations for the given method, starting from the third parameter.
 *///from w  w  w  . jav  a2s .c  om
private List<ParameterInfo<?>> makeParamInfoList(Method method) {
    List<ParameterInfo<?>> paramInfoList = new ArrayList<>();

    Type[] paramTypes = method.getGenericParameterTypes();
    Annotation[][] paramAnnotations = method.getParameterAnnotations();

    for (int i = 0; i < paramAnnotations.length; i++) {
        Annotation[] annotations = paramAnnotations[i];

        //Can have only one from @PathParam, @QueryParam, @HeaderParam or @Context.
        if (Sets.intersection(SUPPORTED_PARAM_ANNOTATIONS, ImmutableSet.of(annotations)).size() > 1) {
            throw new IllegalArgumentException(
                    String.format("Must have exactly one annotation from %s for parameter %d in method %s",
                            SUPPORTED_PARAM_ANNOTATIONS, i, method));
        }

        Annotation annotation = null;
        Type parameterType = paramTypes[i];
        Function<?, Object> converter = null;
        String defaultVal = null;
        for (Annotation annotation0 : annotations) {
            annotation = annotation0;
            Class<? extends Annotation> annotationType = annotation.annotationType();
            if (PathParam.class.isAssignableFrom(annotationType)) {
                converter = ParamConvertUtils.createPathParamConverter(parameterType);
            } else if (QueryParam.class.isAssignableFrom(annotationType)) {
                converter = ParamConvertUtils.createQueryParamConverter(parameterType);
            } else if (HeaderParam.class.isAssignableFrom(annotationType)) {
                converter = ParamConvertUtils.createHeaderParamConverter(parameterType);
            } else if (DefaultValue.class.isAssignableFrom(annotationType)) {
                defaultVal = ((DefaultValue) annotation).value();
            }
        }
        ParameterInfo<?> parameterInfo = ParameterInfo.create(parameterType, annotation, defaultVal, converter);
        paramInfoList.add(parameterInfo);
    }

    return Collections.unmodifiableList(paramInfoList);
}

From source file:org.apache.bookkeeper.stream.storage.impl.sc.ZkStorageContainerManager.java

private boolean refreshMyAssignment() {
    ClusterAssignmentData clusterAssignmentData = metadataStore.getClusterAssignmentData();

    if (null == clusterAssignmentData) {
        log.info("Cluster assignment data is empty, so skip refreshing");
        return false;
    }//from w  w w  .ja va 2 s.  com

    Map<Endpoint, ServerAssignmentData> newAssignmentMap = clusterAssignmentData.getServersMap().entrySet()
            .stream().collect(Collectors.toMap(e -> NetUtils.parseEndpoint(e.getKey()), e -> e.getValue()));

    Set<Endpoint> oldAssignedServers = clusterAssignmentMap.keySet();
    Set<Endpoint> newAssignedServers = newAssignmentMap.keySet();

    Set<Endpoint> serversJoined = Sets.difference(newAssignedServers, oldAssignedServers).immutableCopy();
    Set<Endpoint> serversLeft = Sets.difference(oldAssignedServers, newAssignedServers).immutableCopy();
    Set<Endpoint> commonServers = Sets.intersection(newAssignedServers, oldAssignedServers).immutableCopy();

    processServersLeft(serversLeft, clusterAssignmentMap);
    processServersJoined(serversJoined, newAssignmentMap);
    processServersAssignmentChanged(commonServers, clusterAssignmentMap, newAssignmentMap);

    this.clusterAssignmentMap = newAssignmentMap;
    myAssignmentData = newAssignmentMap.get(endpoint);
    return true;
}

From source file:org.wisdom.router.RequestRouter.java

private boolean hasSameOrOverlappingAcceptedTypes(Route actual, Route other) {
    final Set<MediaType> actualAcceptedMediaTypes = actual.getAcceptedMediaTypes();
    final Set<MediaType> otherAcceptedMediaTypes = other.getAcceptedMediaTypes();

    // Both are empty
    if (actualAcceptedMediaTypes.isEmpty() && otherAcceptedMediaTypes.isEmpty()) {
        return true;
    }/*from   w ww .  j  a v a 2  s  .co  m*/

    // One is empty
    if (actualAcceptedMediaTypes.isEmpty() || otherAcceptedMediaTypes.isEmpty()) {
        return true;
    }

    // None are empty, check intersection
    final Sets.SetView<MediaType> intersection = Sets.intersection(actualAcceptedMediaTypes,
            otherAcceptedMediaTypes);
    return !intersection.isEmpty();
}

From source file:com.jeffreybosboom.lyne.Puzzle.java

public Puzzle restrict(Node a, Node b, Set<Node.Kind> possibilities) {
    return set(a, b, Sets.intersection(possibilities, possibilities(a, b)));
}

From source file:org.apache.gobblin.data.management.retention.policy.CombineRetentionPolicy.java

private Set<T> intersectDatasetVersions(Collection<Set<T>> sets) {
    if (sets.size() <= 0) {
        return Sets.newHashSet();
    }/*from www. j  a  v  a 2s . c o  m*/
    Iterator<Set<T>> it = sets.iterator();
    Set<T> outputSet = it.next();
    while (it.hasNext()) {
        outputSet = Sets.intersection(outputSet, it.next());
    }
    return outputSet;
}

From source file:com.paolodragone.wsn.disambiguation.WsnTermDisambiguator.java

private void lexicalContextFilter(Sense sense, Collection<Sense> targetSenses) {
    String lexicalContext = sense.getLexicalContext();
    if (Strings.isNullOrEmpty(lexicalContext)) {
        return;/*from   w w  w.  j a  va 2s .  co  m*/
    }

    if (LexicalContexts.isValidLexicalContext(lexicalContext)
            && anyWithLexicalContext(lexicalContext, targetSenses)) {
        Set<String> lexicalContextParts = LexicalContexts.getLexicalContextParts(lexicalContext);
        LexicalContexts.filterValidLexicalContextParts(lexicalContextParts);
        Iterator<Sense> targetSenseIterator = targetSenses.iterator();
        while (targetSenseIterator.hasNext()) {
            Sense targetSense = targetSenseIterator.next();
            String targetSenseLexicalContext = targetSense.getLexicalContext();
            Set<String> targetSenseLexicalContextParts = LexicalContexts
                    .getLexicalContextParts(targetSenseLexicalContext);
            LexicalContexts.filterValidLexicalContextParts(targetSenseLexicalContextParts);
            if (Sets.intersection(lexicalContextParts, targetSenseLexicalContextParts).isEmpty()) {
                targetSenseIterator.remove();
            }
        }
    }
}