Refine search
private EqualityInference(Iterable<Set<Expression>> equalityGroups, Set<Expression> derivedExpressions) { ImmutableSetMultimap.Builder<Expression, Expression> setBuilder = ImmutableSetMultimap.builder(); for (Set<Expression> equalityGroup : equalityGroups) { if (!equalityGroup.isEmpty()) { setBuilder.putAll(CANONICAL_ORDERING.min(equalityGroup), equalityGroup); } } equalitySets = setBuilder.build(); ImmutableMap.Builder<Expression, Expression> mapBuilder = ImmutableMap.builder(); for (Map.Entry<Expression, Expression> entry : equalitySets.entries()) { Expression canonical = entry.getKey(); Expression expression = entry.getValue(); mapBuilder.put(expression, canonical); } canonicalMap = mapBuilder.build(); this.derivedExpressions = ImmutableSet.copyOf(derivedExpressions); }
public void testBuilderPutAllIterable() { ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); builder.putAll("foo", Arrays.asList(1, 2, 3)); builder.putAll("bar", Arrays.asList(4, 5)); builder.putAll("foo", Arrays.asList(6, 7)); Multimap<String, Integer> multimap = builder.build(); assertEquals(ImmutableSet.of(1, 2, 3, 6, 7), multimap.get("foo")); assertEquals(ImmutableSet.of(4, 5), multimap.get("bar")); assertEquals(7, multimap.size()); }
throws InvalidCheckpointException ImmutableSetMultimap.Builder<Integer, StreamKind> streamKindsBuilder = ImmutableSetMultimap.builder(); for (Stream stream : streams.values()) { streamKindsBuilder.put(stream.getColumn(), stream.getStreamKind()); SetMultimap<Integer, StreamKind> streamKinds = streamKindsBuilder.build(); ImmutableMap.Builder<StreamId, StreamCheckpoint> checkpoints = ImmutableMap.builder(); for (Map.Entry<StreamId, List<RowGroupIndex>> entry : columnIndexes.entrySet()) { int column = entry.getKey().getColumn();
/** * Creates a graph comprising of the specified vertexes and edges. * * @param vertexes set of graph vertexes * @param edges set of graph edges */ public AdjacencyListsGraph(Set<V> vertexes, Set<E> edges) { checkNotNull(vertexes, "Vertex set cannot be null"); checkNotNull(edges, "Edge set cannot be null"); // Record ingress/egress edges for each vertex. ImmutableSetMultimap.Builder<V, E> srcMap = ImmutableSetMultimap.builder(); ImmutableSetMultimap.Builder<V, E> dstMap = ImmutableSetMultimap.builder(); // Also make sure that all edge end-points are added as vertexes ImmutableSet.Builder<V> actualVertexes = ImmutableSet.builder(); actualVertexes.addAll(vertexes); for (E edge : edges) { srcMap.put(edge.src(), edge); actualVertexes.add(edge.src()); dstMap.put(edge.dst(), edge); actualVertexes.add(edge.dst()); } // Make an immutable copy of the edge and vertex sets this.edges = ImmutableSet.copyOf(edges); this.vertexes = actualVertexes.build(); // Build immutable copies of sources and destinations edge maps sources = srcMap.build(); destinations = dstMap.build(); }
private ClusterIndexes buildIndexes() { // Prepare the index builders ImmutableMap.Builder<DeviceId, TopologyCluster> clusterBuilder = ImmutableMap.builder(); ImmutableSetMultimap.Builder<TopologyCluster, DeviceId> devicesBuilder = ImmutableSetMultimap.builder(); ImmutableSetMultimap.Builder<TopologyCluster, Link> linksBuilder = ImmutableSetMultimap.builder(); // Now scan through all the clusters for (TopologyCluster cluster : clusters.get().values()) { int i = cluster.id().index(); // Scan through all the cluster vertexes. for (TopologyVertex vertex : clusterResults.get().clusterVertexes().get(i)) { devicesBuilder.put(cluster, vertex.deviceId()); clusterBuilder.put(vertex.deviceId(), cluster); } // Scan through all the cluster edges. for (TopologyEdge edge : clusterResults.get().clusterEdges().get(i)) { linksBuilder.put(cluster, edge.link()); } } // Finalize all indexes. return new ClusterIndexes(clusterBuilder.build(), devicesBuilder.build(), linksBuilder.build()); }
public void testBuilderOrderKeysBy() { ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); builder.put("b", 3); builder.put("d", 2); builder.put("a", 5); builder.orderKeysBy(Collections.reverseOrder()); builder.put("c", 4); builder.put("a", 2); builder.put("b", 6); ImmutableSetMultimap<String, Integer> multimap = builder.build(); assertThat(multimap.keySet()).containsExactly("d", "c", "b", "a").inOrder(); assertThat(multimap.values()).containsExactly(2, 4, 3, 6, 5, 2).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("b")).containsExactly(3, 6).inOrder(); assertFalse(multimap.get("a") instanceof ImmutableSortedSet); assertFalse(multimap.get("x") instanceof ImmutableSortedSet); assertFalse(multimap.asMap().get("a") instanceof ImmutableSortedSet); }
/** * Returns an ImmutableSentenceFormModel with the same contents as the * given SentenceFormModel. * * May not actually create a copy if the input is immutable. */ public static ImmutableSentenceFormModel copyOf(SentenceFormModel other) { if (other instanceof ImmutableSentenceDomainModel) { return copyOf(((ImmutableSentenceDomainModel) other).getFormModel()); } else if (other instanceof ImmutableSentenceFormModel) { return (ImmutableSentenceFormModel) other; } ImmutableSetMultimap.Builder<SentenceForm, GdlRule> rulesByForm = ImmutableSetMultimap.builder(); ImmutableSetMultimap.Builder<SentenceForm, GdlSentence> trueSentencesByForm = ImmutableSetMultimap.builder(); for (SentenceForm form : other.getSentenceForms()) { rulesByForm.putAll(form, other.getRules(form)); trueSentencesByForm.putAll(form, other.getSentencesListedAsTrue(form)); } return new ImmutableSentenceFormModel(ImmutableList.copyOf(other.getDescription()), ImmutableSet.copyOf(other.getSentenceForms()), ImmutableSet.copyOf(other.getConstantSentenceForms()), ImmutableSet.copyOf(other.getIndependentSentenceForms()), ImmutableSetMultimap.copyOf(other.getDependencyGraph()), rulesByForm.build(), trueSentencesByForm.build()); }
public ImmutableSetMultimap<String, String> fillInDefaultsFor( ImmutableSetMultimap<String, String> explicitValues) throws InvalidBenchmarkException { ImmutableSetMultimap.Builder<String, String> combined = ImmutableSetMultimap.builder(); // For user parameters, this'll actually be the same as fromClass.keySet(), since any extras // given at the command line are treated as errors; for VM parameters this is not the case. for (String name : Sets.union(map.keySet(), explicitValues.keySet())) { Parameter parameter = map.get(name); ImmutableCollection<String> values = explicitValues.containsKey(name) ? explicitValues.get(name) : parameter.defaults(); combined.putAll(name, values); if (values.isEmpty()) { throw new InvalidBenchmarkException("ERROR: No default value provided for " + name); } } return combined.orderKeysBy(Ordering.natural()).build(); }
/** Converts a {@link Diff} to a {@link ApiDiff}. */ public static ApiDiff fromProto(Diff diff) { ImmutableSet.Builder<String> unsupportedClasses = ImmutableSet.builder(); ImmutableSetMultimap.Builder<String, ClassMemberKey> unsupportedMembersByClass = ImmutableSetMultimap.builder(); for (ApiDiffProto.ClassDiff c : diff.getClassDiffList()) { switch (c.getDiffCase()) { case EVERYTHING_DIFF: unsupportedClasses.add(c.getEverythingDiff().getClassName()); break; case MEMBER_DIFF: ApiDiffProto.MemberDiff memberDiff = c.getMemberDiff(); for (ApiDiffProto.ClassMember member : memberDiff.getMemberList()) { unsupportedMembersByClass.put( memberDiff.getClassName(), ClassMemberKey.create(member.getIdentifier(), member.getMemberDescriptor())); } break; default: throw new AssertionError(c.getDiffCase()); } } return new AutoValue_ApiDiff(unsupportedClasses.build(), unsupportedMembersByClass.build()); }
.collect(toImmutableSet()); ImmutableSet.Builder<Node> activeNodesBuilder = ImmutableSet.builder(); ImmutableSet.Builder<Node> inactiveNodesBuilder = ImmutableSet.builder(); ImmutableSet.Builder<Node> shuttingDownNodesBuilder = ImmutableSet.builder(); ImmutableSet.Builder<Node> coordinatorsBuilder = ImmutableSet.builder(); ImmutableSetMultimap.Builder<ConnectorId, Node> byConnectorIdBuilder = ImmutableSetMultimap.builder(); connectorIds = connectorIds.toLowerCase(ENGLISH); for (String connectorId : CONNECTOR_ID_SPLITTER.split(connectorIds)) { byConnectorIdBuilder.put(new ConnectorId(connectorId), node); byConnectorIdBuilder.put(new ConnectorId(GlobalSystemConnector.NAME), node); break; case INACTIVE: activeNodesByConnectorId = byConnectorIdBuilder.build(); coordinators = coordinatorsBuilder.build();
@Nonnull public static EntityGraph create(OWLEntityData root, ImmutableSet<Edge> edges) { final ImmutableSet.Builder<OWLEntityData> builder = ImmutableSet.builder(); final ImmutableSetMultimap.Builder<OWLEntityData, Edge> edgesByTailNode = ImmutableSetMultimap.builder(); builder.add(root); edges.forEach(e -> { builder.add(e.getTail()); builder.add(e.getHead()); edgesByTailNode.put(e.getTail(), e); }); ImmutableSet<OWLEntityData> nodes = builder.build(); return new AutoValue_EntityGraph(root, nodes.size(), nodes, edges.size(), edges, edgesByTailNode.build()); }
private void addClusterBroadcastSet(TopologyCluster cluster, Builder<ClusterId, ConnectPoint> builder) { // Use the graph root search results to build the broadcast set. Result<TopologyVertex, TopologyEdge> result = DIJKSTRA.search(graph, cluster.root(), null, weight, 1); for (Map.Entry<TopologyVertex, Set<TopologyEdge>> entry : result.parents().entrySet()) { TopologyVertex vertex = entry.getKey(); // Ignore any parents that lead outside the cluster. if (clustersByDevice().get(vertex.deviceId()) != cluster) { continue; } // Ignore any back-link sets that are empty. Set<TopologyEdge> parents = entry.getValue(); if (parents.isEmpty()) { continue; } // Use the first back-link source and destinations to add to the // broadcast set. Link link = parents.iterator().next().link(); builder.put(cluster.id(), link.src()); builder.put(cluster.id(), link.dst()); } }
/** * This method creates a mapping from each index source lookup symbol (directly applied to the index) * to the corresponding probe key Input */ private SetMultimap<Symbol, Integer> mapIndexSourceLookupSymbolToProbeKeyInput(IndexJoinNode node, Map<Symbol, Integer> probeKeyLayout) { Set<Symbol> indexJoinSymbols = node.getCriteria().stream() .map(IndexJoinNode.EquiJoinClause::getIndex) .collect(toImmutableSet()); // Trace the index join symbols to the index source lookup symbols // Map: Index join symbol => Index source lookup symbol Map<Symbol, Symbol> indexKeyTrace = IndexJoinOptimizer.IndexKeyTracer.trace(node.getIndexSource(), indexJoinSymbols); // Map the index join symbols to the probe key Input Multimap<Symbol, Integer> indexToProbeKeyInput = HashMultimap.create(); for (IndexJoinNode.EquiJoinClause clause : node.getCriteria()) { indexToProbeKeyInput.put(clause.getIndex(), probeKeyLayout.get(clause.getProbe())); } // Create the mapping from index source look up symbol to probe key Input ImmutableSetMultimap.Builder<Symbol, Integer> builder = ImmutableSetMultimap.builder(); for (Map.Entry<Symbol, Symbol> entry : indexKeyTrace.entrySet()) { Symbol indexJoinSymbol = entry.getKey(); Symbol indexLookupSymbol = entry.getValue(); builder.putAll(indexLookupSymbol, indexToProbeKeyInput.get(indexJoinSymbol)); } return builder.build(); }
private <T> SetMultimap<T, T> createMapping(List<T> keys, List<T> values) { checkArgument(keys.size() == values.size(), "Inputs must have the same size"); ImmutableSetMultimap.Builder<T, T> builder = ImmutableSetMultimap.builder(); for (int i = 0; i < keys.size(); i++) { builder.put(keys.get(i), values.get(i)); } return builder.build(); }
/** * Groups {@code binding}'s implicit dependencies by their binding key, using the dependency keys * from the {@link Binding#unresolved()} binding if it exists. */ private ImmutableList<Set<DependencyRequest>> groupByUnresolvedKey() { ImmutableSetMultimap.Builder<Key, DependencyRequest> dependenciesByKeyBuilder = ImmutableSetMultimap.builder(); Iterator<DependencyRequest> dependencies = dependencies().iterator(); Binding unresolved = unresolved().isPresent() ? unresolved().get() : this; Iterator<DependencyRequest> unresolvedDependencies = unresolved.dependencies().iterator(); while (dependencies.hasNext()) { dependenciesByKeyBuilder.put(unresolvedDependencies.next().key(), dependencies.next()); } return ImmutableList.copyOf( Multimaps.asMap( dependenciesByKeyBuilder.orderValuesBy(SourceFiles.DEPENDENCY_ORDERING).build()) .values()); }
public void testBuilderPutAllMultimapWithDuplicates() { Multimap<String, Integer> toPut = LinkedListMultimap.create(); toPut.put("foo", 1); toPut.put("bar", 4); toPut.put("foo", 2); toPut.put("foo", 1); toPut.put("bar", 5); ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); builder.putAll(toPut); ImmutableSetMultimap<String, Integer> multimap = builder.build(); assertEquals(4, multimap.size()); }
public void testFlatteningToImmutableSetMultimap() { Collector<String, ?, ImmutableSetMultimap<Character, Character>> collector = ImmutableSetMultimap.flatteningToImmutableSetMultimap( str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c)); BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence = Equivalence.equals() .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet())) .and(Equivalence.equals()); ImmutableSetMultimap<Character, Character> empty = ImmutableSetMultimap.of(); ImmutableSetMultimap<Character, Character> filled = ImmutableSetMultimap.<Character, Character>builder() .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a')) .putAll('a', Arrays.asList('p', 'p', 'l', 'e')) .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't')) .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's')) .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y')) .build(); CollectorTester.of(collector, equivalence) .expectCollects(empty) .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry"); }