Example usage for com.google.common.collect SetMultimap containsKey

Introduction

In this page you can find the example usage for com.google.common.collect SetMultimap containsKey.

Prototype

boolean containsKey(@Nullable Object key);

Source Link

Document

Returns true if this multimap contains at least one key-value pair with the key key .

Usage

From source file:com.google.devtools.build.lib.query2.output.ConditionalEdges.java

/** Builds ConditionalEdges from given graph. */
public ConditionalEdges(Digraph<Target> graph) {
    this.map = new HashMap<>();

    for (Node<Target> node : graph.getNodes()) {
        Rule rule = node.getLabel().getAssociatedRule();
        if (rule == null) {
            // rule is null for source files and package groups. Skip them.
            continue;
        }/*from w ww  .  j  a  v  a2 s. co m*/

        SetMultimap<Label, Label> conditions = getAllConditions(rule, RawAttributeMapper.of(rule));
        if (conditions.isEmpty()) {
            // bail early for most common case of no conditions in the rule.
            continue;
        }

        Label nodeLabel = node.getLabel().getLabel();
        for (Node<Target> succ : node.getSuccessors()) {
            Label successorLabel = succ.getLabel().getLabel();
            if (conditions.containsKey(successorLabel)) {
                insert(nodeLabel, successorLabel, conditions.get(successorLabel));
            }
        }
    }
}

---

From source file:org.dragoneronca.nlp.wol.graph_building.SimilarityBasedProcessor.java

private Map<Sense, Double> computeProbabilityMap(Sense sense, Set<Sense> targetSenses,
        SetMultimap<Sense, Tuple> senseContexts) {
    Map<Sense, Double> probabilityMap = new HashMap<>();

    double normSum = 0;
    Iterator<Sense> targetSenseIt = targetSenses.iterator();
    while (targetSenseIt.hasNext()) {
        Sense targetSense = targetSenseIt.next();
        if (!senseContexts.containsKey(targetSense)) {
            Set<Tuple> referredContext = getGlossContext(targetSense.getTaggedGloss());
            senseContexts.putAll(targetSense, referredContext);
        }/*from ww w.jav a2s .c o m*/

        double similarity = SIMILARITY.getSimilarity(senseContexts.get(sense), senseContexts.get(targetSense));

        if (similarity >= SIMILARITY_THRESHOLD) {
            probabilityMap.put(targetSense, similarity);
            normSum += similarity;
        } else {
            targetSenseIt.remove();
        }
    }

    if (normSum == 0) {
        double uniformProb = 1.0 / targetSenses.size();
        for (Sense targetSense : targetSenses) {
            probabilityMap.put(targetSense, uniformProb);
        }
    } else {
        for (Sense targetSense : targetSenses) {
            double normProbability = probabilityMap.get(targetSense) / normSum;
            probabilityMap.put(targetSense, normProbability);
        }
    }

    return probabilityMap;
}

---

From source file:dagger.internal.codegen.MapMultibindingValidator.java

/**
 * Returns the map multibindings in the binding graph. If a graph contains bindings for more than
 * one of the following for the same {@code K} and {@code V}, then only the first one found will
 * be returned so we don't report the same map contribution problem more than once.
 *
 * <ol>/*from  www . ja v  a2 s  .  c  o m*/
 *   <li>{@code Map<K, V>}
 *   <li>{@code Map<K, Provider<V>>}
 *   <li>{@code Map<K, Producer<V>>}
 * </ol>
 */
private ImmutableSet<dagger.model.Binding> mapMultibindings(BindingGraph bindingGraph) {
    ImmutableSetMultimap<Key, dagger.model.Binding> mapMultibindings = bindingGraph.bindings().stream()
            .filter(node -> node.kind().equals(MULTIBOUND_MAP))
            .collect(toImmutableSetMultimap(dagger.model.Binding::key, node -> node));

    // Mutlbindings for Map<K, V>
    SetMultimap<Key, dagger.model.Binding> plainValueMapMultibindings = filterKeys(mapMultibindings,
            key -> !MapType.from(key).valuesAreFrameworkType());

    // Multibindings for Map<K, Provider<V>> where Map<K, V> isn't in plainValueMapMultibindings
    SetMultimap<Key, dagger.model.Binding> providerValueMapMultibindings = filterKeys(mapMultibindings,
            key -> MapType.from(key).valuesAreTypeOf(Provider.class)
                    && !plainValueMapMultibindings.containsKey(keyFactory.unwrapMapValueType(key)));

    // Multibindings for Map<K, Producer<V>> where Map<K, V> isn't in plainValueMapMultibindings and
    // Map<K, Provider<V>> isn't in providerValueMapMultibindings
    SetMultimap<Key, dagger.model.Binding> producerValueMapMultibindings = filterKeys(mapMultibindings,
            key -> MapType.from(key).valuesAreTypeOf(Producer.class)
                    && !plainValueMapMultibindings.containsKey(keyFactory.unwrapMapValueType(key))
                    && !providerValueMapMultibindings
                            .containsKey(keyFactory.rewrapMapKey(key, Producer.class, Provider.class).get()));

    return new ImmutableSet.Builder<dagger.model.Binding>().addAll(plainValueMapMultibindings.values())
            .addAll(providerValueMapMultibindings.values()).addAll(producerValueMapMultibindings.values())
            .build();
}

---

From source file:tiger.NewDependencyCollector.java

private void checkOneDependency(SetMultimap<NewBindingKey, NewDependencyInfo> existingDependencies,
        NewDependencyInfo newInfo) {//from  w w w .j ava2  s.  c  o m
    Preconditions.checkNotNull(newInfo);
    if (existingDependencies.containsKey(newInfo.getDependant())) {
        Set<NewDependencyInfo> dependencyInfoSet = existingDependencies.get(newInfo.getDependant());
        NewDependencyInfo existingDependencyInfo = Preconditions
                .checkNotNull(Iterables.getFirst(dependencyInfoSet, null));
        if (existingDependencyInfo.getType().equals(Provides.Type.UNIQUE)
                || newInfo.getType().equals(Provides.Type.UNIQUE)) {
            String error = String.format("Adding dependencies failed.\n %s\nAlready existing: %s", newInfo,
                    dependencyInfoSet);
            errors.add(error);
        }
    }
}

---

From source file:ome.services.blitz.repo.path.FilePathRestrictions.java

/**
 * Combine sets of rules to form a set that satisfies them all.
 * @param rules at least one set of rules
 * @return the intersection of the given rules
 *//*from  w  w  w .j a v  a  2 s . c  o m*/
private static FilePathRestrictions combineRules(FilePathRestrictions... rules) {
    if (rules.length == 0) {
        throw new IllegalArgumentException("cannot combine an empty list of rules");
    }

    int index = 0;
    FilePathRestrictions product = rules[index++];

    while (index < rules.length) {
        final FilePathRestrictions toCombine = rules[index++];

        final Set<Character> safeCharacters = Sets.intersection(product.safeCharacters,
                toCombine.safeCharacters);

        if (safeCharacters.isEmpty()) {
            throw new IllegalArgumentException("cannot combine safe characters");
        }

        final Set<Integer> allKeys = Sets.union(product.transformationMatrix.keySet(),
                toCombine.transformationMatrix.keySet());
        final ImmutableMap<Integer, Collection<Integer>> productMatrixMap = product.transformationMatrix
                .asMap();
        final ImmutableMap<Integer, Collection<Integer>> toCombineMatrixMap = toCombine.transformationMatrix
                .asMap();
        final SetMultimap<Integer, Integer> newTransformationMatrix = HashMultimap.create();

        for (final Integer key : allKeys) {
            final Collection<Integer> values;
            if (!productMatrixMap.containsKey(key)) {
                values = toCombineMatrixMap.get(key);
            } else if (!toCombineMatrixMap.containsKey(key)) {
                values = productMatrixMap.get(key);
            } else {
                final Set<Integer> valuesSet = new HashSet<Integer>(productMatrixMap.get(key));
                valuesSet.retainAll(toCombineMatrixMap.get(key));
                if (valuesSet.isEmpty()) {
                    throw new IllegalArgumentException(
                            "cannot combine transformations for Unicode code point " + key);
                }
                values = valuesSet;
            }
            for (final Integer value : values) {
                newTransformationMatrix.put(key, value);
            }
        }

        final SetMultimap<Integer, Integer> entriesRemoved = HashMultimap.create();
        boolean transitiveClosing;
        do {
            transitiveClosing = false;
            for (final Entry<Integer, Integer> transformation : newTransformationMatrix.entries()) {
                final int to = transformation.getValue();
                if (newTransformationMatrix.containsKey(to)) {
                    final int from = transformation.getKey();
                    if (!entriesRemoved.put(from, to)) {
                        throw new IllegalArgumentException(
                                "cyclic transformation involving Unicode code point " + from);
                    }
                    newTransformationMatrix.remove(from, to);
                    newTransformationMatrix.putAll(from, newTransformationMatrix.get(to));
                    transitiveClosing = true;
                    break;
                }
            }
        } while (transitiveClosing);

        product = new FilePathRestrictions(newTransformationMatrix,
                Sets.union(product.unsafePrefixes, toCombine.unsafePrefixes),
                Sets.union(product.unsafeSuffixes, toCombine.unsafeSuffixes),
                Sets.union(product.unsafeNames, toCombine.unsafeNames), safeCharacters);
    }
    return product;
}

---

From source file:com.google.errorprone.bugpatterns.RedundantThrows.java

@Override
public Description matchMethod(MethodTree tree, VisitorState state) {
    List<? extends ExpressionTree> thrown = tree.getThrows();
    if (thrown.isEmpty()) {
        return NO_MATCH;
    }/*from  www. j  a v a  2  s  .  c o m*/
    SetMultimap<Symbol, ExpressionTree> exceptionsBySuper = LinkedHashMultimap.create();
    for (ExpressionTree exception : thrown) {
        Type type = getType(exception);
        do {
            type = state.getTypes().supertype(type);
            exceptionsBySuper.put(type.tsym, exception);
        } while (!state.getTypes().isSameType(type, state.getSymtab().objectType));
    }
    Set<ExpressionTree> toRemove = new HashSet<>();
    List<String> messages = new ArrayList<>();
    for (ExpressionTree exception : thrown) {
        Symbol sym = getSymbol(exception);
        if (exceptionsBySuper.containsKey(sym)) {
            Set<ExpressionTree> sub = exceptionsBySuper.get(sym);
            messages.add(String.format("%s %s of %s", oxfordJoin(", ", sub),
                    sub.size() == 1 ? "is a subtype" : "are subtypes", sym.getSimpleName()));
            toRemove.addAll(sub);
        }
    }
    if (toRemove.isEmpty()) {
        return NO_MATCH;
    }
    // sort by order in input
    List<ExpressionTree> delete = ImmutableList
            .<ExpressionTree>copyOf(Iterables.filter(tree.getThrows(), Predicates.in(toRemove)));
    return buildDescription(delete.get(0)).setMessage("Redundant throws clause: " + oxfordJoin("; ", messages))
            .addFix(SuggestedFixes.deleteExceptions(tree, state, delete)).build();
}

---

From source file:tiger.Utils.java

/**
 * Return {@link NewDependencyInfo} for the generalized {@link NewBindingKey} for
 * the give key. Null if not applicable or not exist.
 *//*from w  ww. j a v  a2s  .  c om*/
public static NewDependencyInfo getDependencyInfoByGeneric(
        SetMultimap<NewBindingKey, NewDependencyInfo> dependencies, NewBindingKey key) {
    TypeName typeName = key.getTypeName();
    Preconditions.checkArgument(key.getQualifier() == null,
            String.format("Binding to %s is supposed to be resolved through generic type of %s"
                    + "but has non-null qualifier.", key, typeName));
    if (typeName instanceof ParameterizedTypeName) {
        ParameterizedTypeName parameterizedTypeName = (ParameterizedTypeName) typeName;
        ClassName rawTypeName = parameterizedTypeName.rawType;
        NewBindingKey rawKey = NewBindingKey.get(rawTypeName);
        if (dependencies.containsKey(rawKey)) {
            NewDependencyInfo dependencyInfo = Iterables.getOnlyElement(dependencies.get(rawKey));
            TypeName formalTypeName = dependencyInfo.getDependant().getTypeName();
            Preconditions.checkState(formalTypeName instanceof ParameterizedTypeName,
                    String.format(
                            "Formal type %s is not of type ParameterizedTypeName. Related actual type is %s",
                            formalTypeName, parameterizedTypeName));

            Map<TypeVariableName, TypeName> mapTypeVariableToSpecialized = getMapFromTypeVariableToSpecialized(
                    parameterizedTypeName, (ParameterizedTypeName) formalTypeName);
            Set<NewBindingKey> specializedDependencies = specializeIfNeeded(dependencyInfo.getDependencies(),
                    mapTypeVariableToSpecialized);
            return new NewDependencyInfo(key, specializedDependencies, dependencyInfo.getSourceClassElement(),
                    dependencyInfo.getProvisionMethodElement(), dependencyInfo.getType());
        }
    }
    return null;
}

---

From source file:fr.openwide.core.jpa.security.hierarchy.PermissionHierarchyImpl.java

private SetMultimap<Permission, Permission> buildClosures(
        SetMultimap<Permission, Permission> oneStepRelations) {
    SetMultimap<Permission, Permission> closures = HashMultimap.create();
    // iterate over all higher permissions from permissionsAcceptableInOneStepMap
    Iterator<Permission> permissionIterator = oneStepRelations.keySet().iterator();

    while (permissionIterator.hasNext()) {
        Permission permission = (Permission) permissionIterator.next();
        Set<Permission> permissionsToVisitSet = new HashSet<Permission>();

        if (oneStepRelations.containsKey(permission)) {
            permissionsToVisitSet.addAll(oneStepRelations.get(permission));
        }//from   w  ww.ja  v a2 s  .  c  o  m

        Set<Permission> visitedPermissionsSet = new HashSet<Permission>();

        while (!permissionsToVisitSet.isEmpty()) {
            // take a permission from the permissionsToVisit set
            Permission aPermission = (Permission) permissionsToVisitSet.iterator().next();
            permissionsToVisitSet.remove(aPermission);
            visitedPermissionsSet.add(aPermission);
            if (closures.containsKey(aPermission)) {
                Set<Permission> newClosure = (Set<Permission>) closures.get(aPermission);

                // definition of a cycle: you can reach the permission you are starting from
                if (permissionsToVisitSet.contains(permission) || visitedPermissionsSet.contains(permission)) {
                    throw new CycleInPermissionHierarchyException();
                } else {
                    // no cycle
                    permissionsToVisitSet.addAll(newClosure);
                }
            }
        }
        closures.putAll(permission, visitedPermissionsSet);
    }

    return closures;

}

---

From source file:org.robotframework.ide.eclipse.main.plugin.model.RobotSuiteFile.java

public SetMultimap<LibrarySpecification, String> getImportedLibraries() {
    final Optional<RobotSettingsSection> section = findSection(RobotSettingsSection.class);
    final SetMultimap<String, String> toImport = HashMultimap.create();
    if (section.isPresent()) {
        toImport.putAll(section.get().getLibrariesPathsOrNamesWithAliases());
    }// w w  w. j  a va 2 s. c  om

    final SetMultimap<LibrarySpecification, String> imported = HashMultimap.create();
    for (final LibrarySpecification spec : getProject().getLibrariesSpecifications()) {
        if (toImport.containsKey(spec.getName())) {
            imported.putAll(spec, toImport.get(spec.getName()));
            toImport.removeAll(spec.getName());
        } else if (spec.isAccessibleWithoutImport()) {
            imported.put(spec, "");
        }
    }
    for (final String toImportPathOrName : toImport.keySet()) {
        try {
            final LibrarySpecification spec = findSpecForPath(toImportPathOrName);
            if (spec != null) {
                imported.putAll(spec, toImport.get(toImportPathOrName));
            }
        } catch (final PathResolvingException e) {
            // ok we won't provide any spec, since we can't resolve uri
        }
    }
    return imported;
}

---

From source file:tiger.NewDependencyCollector.java

/**
 * Add dependencies from ctor injected classes needed by requiredKeys recursively to result.
 *//*w  w  w. j a  v  a  2  s.  co  m*/
private void addDependenciesForRequiredKeys(SetMultimap<NewBindingKey, NewDependencyInfo> result,
        Set<NewBindingKey> requiredKeys) {
    // Added all the required dependencies from ctor injected classes.
    while (!requiredKeys.isEmpty()) {
        NewBindingKey key = Iterables.getFirst(requiredKeys, null);
        Preconditions.checkNotNull(key);
        requiredKeys.remove(key);
        if (result.containsKey(key)) {
            continue;
        }

        TypeName typeName = key.getTypeName();
        if (Utils.hasBuiltinBinding(typeName)) {
            key = Utils.getElementKeyForBuiltinBinding(key);
            requiredKeys.add(key);
            continue;
        }

        if (Utils.isMapWithBuiltinValueType(key)) {
            NewBindingKey peeledMapKey = Preconditions.checkNotNull(Utils.peelMapWithBuiltinValue(key));
            requiredKeys.add(peeledMapKey);
            continue;
        }

        ClassName className;
        if (typeName instanceof ClassName) {
            className = (ClassName) typeName;
        } else {
            Preconditions.checkState(typeName instanceof ParameterizedTypeName, "Expect a %s but get %s",
                    ParameterizedTypeName.class, typeName);
            ParameterizedTypeName parameterizedTypeName = (ParameterizedTypeName) typeName;
            for (TypeName parameter : parameterizedTypeName.typeArguments) {
                Preconditions.checkState(
                        parameter instanceof ClassName || parameter instanceof ParameterizedTypeName,
                        String.format("Unexpected parameter type %s for type %s.", parameter, typeName));
            }
            NewDependencyInfo dependencyInfo = Utils.getDependencyInfoByGeneric(result, key);
            if (dependencyInfo != null) {
                requiredKeys.addAll(dependencyInfo.getDependencies());
                continue;
            } else {
                className = ((ParameterizedTypeName) typeName).rawType;
            }
        }
        TypeElement classTypeElement = env.getElementUtils()
                .getTypeElement(Utils.getClassCanonicalName(className));
        Preconditions.checkNotNull(classTypeElement, String.format("Class %s not found.", className));
        Collection<NewDependencyInfo> dependencies = collectFromCtorInjectedClass(classTypeElement);
        if (dependencies == null) {
            messager.printMessage(Kind.ERROR, String.format("Binding not found for %s", key));
            continue;
        }
        NewDependencyInfo dependency = Iterables.getOnlyElement(dependencies);
        if (typeName instanceof ParameterizedTypeName) {
            Map<TypeVariableName, TypeName> parameterMap = Utils.getMapFromTypeVariableToSpecialized(
                    (ParameterizedTypeName) typeName,
                    (ParameterizedTypeName) dependency.getDependant().getTypeName());
            requiredKeys.addAll(Utils.specializeIfNeeded(dependency.getDependencies(), parameterMap));
        } else {
            requiredKeys.addAll(dependency.getDependencies());
        }
        checkOneDependency(result, dependency);
        addDependencyInfo(result, dependency);
    }
}

---

• «
• 1
• 2
• 3
• »