List of usage examples for com.google.common.collect SetMultimap keySet
Set<K> keySet();
From source file:com.b2international.snowowl.snomed.core.tree.TreeBuilderImpl.java
@Override public TerminologyTree build(final String branch, final Iterable<SnomedConceptDocument> nodes) { final Collection<SnomedConceptDocument> topLevelConcepts = this.topLevelConcepts == null ? getDefaultTopLevelConcepts(branch) : this.topLevelConcepts; final Map<String, SnomedConceptDocument> treeItemsById = newHashMap(); // all matching concepts should be in the componentMap treeItemsById.putAll(FluentIterable.from(nodes).uniqueIndex(ComponentUtils.<String>getIdFunction())); final Collection<String> requiredTopLevelConceptIds = ComponentUtils.getIdSet(topLevelConcepts); // compute subType and superType maps for the tree final SetMultimap<String, String> superTypeMap = HashMultimap.create(); final SetMultimap<String, String> subTypeMap = HashMultimap.create(); for (SnomedConceptDocument entry : nodes) { final LongCollection parentIds = getParents(entry); final LongCollection ancestorIds = getAncestors(entry); if (parentIds != null) { final Collection<String> parents = LongSets.toStringSet(parentIds); final Collection<String> selectedParents = newHashSet(); // if the parent is not a match or TOP level for (String parent : parents) { if (treeItemsById.containsKey(parent) || requiredTopLevelConceptIds.contains(parent)) { selectedParents.add(parent); }/*from www.j a va 2 s.c om*/ } if (selectedParents.isEmpty()) { findParentInAncestors(entry, treeItemsById, requiredTopLevelConceptIds, subTypeMap, superTypeMap); } else { for (String parent : selectedParents) { subTypeMap.put(parent, entry.getId()); superTypeMap.put(entry.getId(), parent); } } } else if (ancestorIds != null) { findParentInAncestors(entry, treeItemsById, requiredTopLevelConceptIds, subTypeMap, superTypeMap); } else { // no parents or ancestors, root element subTypeMap.put(null, entry.getId()); } } // add TOP levels for (SnomedConceptDocument entry : topLevelConcepts) { if (!Concepts.ROOT_CONCEPT.equals(entry.getId()) && !treeItemsById.containsKey(entry.getId())) { if (subTypeMap.containsKey(entry.getId())) { treeItemsById.put(entry.getId(), entry); } } } for (SnomedConceptDocument entry : topLevelConcepts) { if (Concepts.ROOT_CONCEPT.equals(entry.getId())) { // find all top level child and connect them with the root for (SnomedConceptDocument tl : topLevelConcepts) { if (!Concepts.ROOT_CONCEPT.equals(tl.getId()) && treeItemsById.containsKey(tl.getId())) { subTypeMap.put(entry.getId(), tl.getId()); superTypeMap.put(tl.getId(), entry.getId()); } } // only add root concept if the tree contains top level concepts if (subTypeMap.containsKey(Concepts.ROOT_CONCEPT)) { treeItemsById.put(entry.getId(), entry); subTypeMap.put(null, entry.getId()); } break; } } // fetch all missing components to build the remaining part of the FULL tree final Set<String> allRequiredComponents = newHashSet(); allRequiredComponents.addAll(superTypeMap.keySet()); allRequiredComponents.addAll(subTypeMap.keySet()); allRequiredComponents.removeAll(treeItemsById.keySet()); allRequiredComponents.remove(null); // fetch required data for all unknown items for (SnomedConceptDocument entry : getComponents(branch, allRequiredComponents)) { treeItemsById.put(entry.getId(), entry); } return new TerminologyTree(treeItemsById, subTypeMap, superTypeMap); }
From source file:com.analog.lyric.dimple.model.transform.JunctionTreeTransform.java
private List<CliqueEdge> formSpanningTree(JunctionTreeTransformMap transformMap, List<Clique> cliques, SetMultimap<Discrete, Clique> varToCliques) { final int nCliques = cliques.size(); assert (nCliques > 0); final IHeap<Clique> heap = BinaryHeap.create(nCliques); heap.deferOrderingForBulkAdd(nCliques); Clique maxClique = null;// w ww .j a v a 2 s . c o m for (Clique clique : cliques) { if (maxClique == null || clique.size() > maxClique.size()) { maxClique = clique; } clique._heapEntry = heap.offer(clique, Double.POSITIVE_INFINITY); } requireNonNull(maxClique); heap.changePriority(requireNonNull(maxClique._heapEntry), Double.NEGATIVE_INFINITY); // Edges with more than one variable List<CliqueEdge> multiVariateEdges = Lists.newArrayListWithCapacity(nCliques - 1); final FactorGraph targetModel = transformMap.target(); for (Clique clique; (clique = heap.poll()) != null;) { clique._inSpanningTree = true; clique._heapEntry = null; final CliqueEdge addedEdge = clique._bestEdge; if (addedEdge != null) { final Clique prevClique = addedEdge._from; if (addedEdge.isMergeable()) { if (requireNonNull(prevClique).absorbClique(clique, varToCliques)) { clique = prevClique; } else { clique = null; } } else { final AddedJointVariable<?> addedVar = addedEdge.makeJointVariable(targetModel); if (addedVar != null) { multiVariateEdges.add(addedEdge); transformMap.addDeterministicVariable(addedVar); } requireNonNull(prevClique).addEdge(addedEdge); clique.addEdge(addedEdge); } } if (clique != null) { for (CliqueEdge edge : edgesNotInTree(clique, varToCliques)) { final Clique targetClique = edge._to; if (targetClique.updateBestEdge(edge)) { // Use negative weight because IHeap implements a min heap. heap.changePriority(Objects.requireNonNull(targetClique._heapEntry), -edge._weight); } } } } // Add half-edges for variables that are in only one clique and therefore won't be in any // edge created in the previous step. for (Discrete var : varToCliques.keySet()) { final Set<Clique> cliquesForVar = varToCliques.get(var); if (cliquesForVar.size() == 1) { final Clique clique = Iterables.getOnlyElement(cliquesForVar); clique.addEdge(new CliqueEdge(null, clique, var)); } } return multiVariateEdges; }
From source file:dagger.internal.codegen.ComponentValidator.java
/** * Validates the given component subject. Also validates any referenced subcomponents that aren't * already included in the {@code validatedSubcomponents} set. *///from w w w . java 2s . c o m public ComponentValidationReport validate(final TypeElement subject, Set<? extends Element> validatedSubcomponents, Set<? extends Element> validatedSubcomponentBuilders) { ValidationReport.Builder<TypeElement> builder = ValidationReport.about(subject); ComponentDescriptor.Kind componentKind = ComponentDescriptor.Kind.forAnnotatedElement(subject).get(); if (!subject.getKind().equals(INTERFACE) && !(subject.getKind().equals(CLASS) && subject.getModifiers().contains(ABSTRACT))) { builder.addError(String.format("@%s may only be applied to an interface or abstract class", componentKind.annotationType().getSimpleName()), subject); } ImmutableList<DeclaredType> builders = enclosedBuilders(subject, componentKind.builderAnnotationType()); if (builders.isEmpty()) { final String subjectName = subject.getQualifiedName().toString(); builder.addError( String.format(ErrorMessages.builderMsgsFor(componentKind).noBuilderPresent(), subjectName)); } if (builders.size() > 1) { builder.addError(String.format(ErrorMessages.builderMsgsFor(componentKind).moreThanOne(), builders), subject); } Optional<AnnotationMirror> reusableAnnotation = getAnnotationMirror(subject, Reusable.class); if (reusableAnnotation.isPresent()) { builder.addError(COMPONENT_ANNOTATED_REUSABLE, subject, reusableAnnotation.get()); } DeclaredType subjectType = MoreTypes.asDeclared(subject.asType()); SetMultimap<Element, ExecutableElement> referencedSubcomponents = LinkedHashMultimap.create(); getLocalAndInheritedMethods(subject, types, elements).stream() .filter(method -> method.getModifiers().contains(ABSTRACT)).forEachOrdered(method -> { ExecutableType resolvedMethod = asExecutable(types.asMemberOf(subjectType, method)); List<? extends TypeMirror> parameterTypes = resolvedMethod.getParameterTypes(); List<? extends VariableElement> parameters = method.getParameters(); TypeMirror returnType = resolvedMethod.getReturnType(); // abstract methods are ones we have to implement, so they each need to be validated // first, check the return type. if it's a subcomponent, validate that method as such. Optional<AnnotationMirror> subcomponentAnnotation = checkForAnnotations(returnType, FluentIterable.from(componentKind.subcomponentKinds()).transform(Kind::annotationType) .toSet()); Optional<AnnotationMirror> subcomponentBuilderAnnotation = checkForAnnotations(returnType, FluentIterable.from(componentKind.subcomponentKinds()) .transform(Kind::builderAnnotationType).toSet()); if (subcomponentAnnotation.isPresent()) { referencedSubcomponents.put(MoreTypes.asElement(returnType), method); validateSubcomponentMethod(builder, ComponentDescriptor.Kind.forAnnotatedElement(MoreTypes.asTypeElement(returnType)) .get(), method, parameters, parameterTypes, returnType, subcomponentAnnotation); } else if (subcomponentBuilderAnnotation.isPresent()) { referencedSubcomponents.put(MoreTypes.asElement(returnType).getEnclosingElement(), method); validateSubcomponentBuilderMethod(builder, method, parameters, returnType, validatedSubcomponentBuilders); } else { // if it's not a subcomponent... switch (parameters.size()) { case 0: // no parameters means that it is a provision method // basically, there are no restrictions here. \o/ break; case 1: // one parameter means that it's a members injection method TypeMirror onlyParameter = Iterables.getOnlyElement(parameterTypes); if (!(returnType.getKind().equals(VOID) || types.isSameType(returnType, onlyParameter))) { builder.addError( "Members injection methods may only return the injected type or void.", method); } break; default: // this isn't any method that we know how to implement... builder.addError( "This method isn't a valid provision method, members injection method or " + "subcomponent factory method. Dagger cannot implement this method", method); break; } } }); Maps.filterValues(referencedSubcomponents.asMap(), methods -> methods.size() > 1) .forEach((subcomponent, methods) -> builder.addError(String.format( ErrorMessages.SubcomponentBuilderMessages.INSTANCE.moreThanOneRefToSubcomponent(), subcomponent, methods), subject)); AnnotationMirror componentMirror = getAnnotationMirror(subject, componentKind.annotationType()).get(); if (componentKind.isTopLevel()) { validateComponentDependencies(builder, getComponentDependencies(componentMirror)); } builder.addSubreport( moduleValidator.validateReferencedModules(subject, componentMirror, componentKind.moduleKinds())); // Make sure we validate any subcomponents we're referencing, unless we know we validated // them already in this pass. // TODO(sameb): If subcomponents refer to each other and both aren't in // 'validatedSubcomponents' (e.g, both aren't compiled in this pass), // then this can loop forever. ImmutableSet.Builder<Element> allSubcomponents = ImmutableSet.<Element>builder() .addAll(referencedSubcomponents.keySet()); for (Element subcomponent : Sets.difference(referencedSubcomponents.keySet(), validatedSubcomponents)) { ComponentValidationReport subreport = subcomponentValidator.validate(MoreElements.asType(subcomponent), validatedSubcomponents, validatedSubcomponentBuilders); builder.addItems(subreport.report().items()); allSubcomponents.addAll(subreport.referencedSubcomponents()); } return new AutoValue_ComponentValidator_ComponentValidationReport(allSubcomponents.build(), builder.build()); }