Set<Feature<?>> computeMultimapGetFeatures(Set<Feature<?>> multimapFeatures) { Set<Feature<?>> derivedFeatures = Helpers.copyToSet(multimapFeatures); for (Entry<Feature<?>, Feature<?>> entry : GET_FEATURE_MAP.entries()) { if (derivedFeatures.contains(entry.getKey())) { derivedFeatures.add(entry.getValue()); } } if (derivedFeatures.remove(MultimapFeature.VALUE_COLLECTIONS_SUPPORT_ITERATOR_REMOVE)) { derivedFeatures.add(CollectionFeature.SUPPORTS_ITERATOR_REMOVE); } if (!derivedFeatures.contains(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) { derivedFeatures.remove(CollectionFeature.SERIALIZABLE); } derivedFeatures.removeAll(GET_FEATURE_MAP.keySet()); return derivedFeatures; }
public Set<ContentPack> loadAllLatest() { final Set<ContentPack> allContentPacks = loadAll(); final ImmutableMultimap.Builder<ModelId, ContentPack> byIdBuilder = ImmutableMultimap.builder(); for (ContentPack contentPack : allContentPacks) { byIdBuilder.put(contentPack.id(), contentPack); } final ImmutableMultimap<ModelId, ContentPack> contentPacksById = byIdBuilder.build(); final ImmutableSet.Builder<ContentPack> latestContentPacks = ImmutableSet.builderWithExpectedSize(contentPacksById.keySet().size()); for (ModelId id : contentPacksById.keySet()) { final ImmutableCollection<ContentPack> contentPacks = contentPacksById.get(id); final ContentPack latestContentPackRevision = Collections.max(contentPacks, Comparator.comparingInt(Revisioned::revision)); latestContentPacks.add(latestContentPackRevision); } return latestContentPacks.build(); }
public void testNotifyStoppedAfterFailure() throws TimeoutException { Service a = new AbstractService() { @Override protected void doStart() { notifyFailed(new IllegalStateException("start failure")); notifyStopped(); // This will be a no-op. } @Override protected void doStop() { notifyStopped(); } }; final ServiceManager manager = new ServiceManager(asList(a)); manager.startAsync(); manager.awaitStopped(10, TimeUnit.MILLISECONDS); assertThat(manager.servicesByState().keySet()).containsExactly(Service.State.FAILED); }
public void testDoCancelStart() throws TimeoutException { Service a = new AbstractService() { @Override protected void doStart() { // Never starts! } @Override protected void doCancelStart() { assertThat(state()).isEqualTo(Service.State.STOPPING); notifyStopped(); } @Override protected void doStop() { throw new AssertionError(); // Should not be called. } }; final ServiceManager manager = new ServiceManager(asList(a)); manager.startAsync(); manager.stopAsync(); manager.awaitStopped(10, TimeUnit.MILLISECONDS); assertThat(manager.servicesByState().keySet()).containsExactly(Service.State.TERMINATED); }
Set<String> matchingClassNames = Sets.newLinkedHashSet(); Iterator<String> i = classNameLocations.keySet().iterator(); if (instrumentation != null) { List<String> loadedClassNames = Lists.newArrayList();
private static NativeLibraries filterNativeTargeting( NativeLibraries nativeLibraries, ImmutableMultimap<ZipPath, ModuleEntry> preservedEntriesByAbiDir) { ImmutableSet<String> preservedAbiDirs = preservedEntriesByAbiDir.keySet().stream().map(ZipPath::toString).collect(toImmutableSet()); return nativeLibraries .toBuilder() .clearDirectory() .addAllDirectory( nativeLibraries.getDirectoryList().stream() .filter(targetedDirectory -> preservedAbiDirs.contains(targetedDirectory.getPath())) .collect(toImmutableList())) .build(); } }
@Test @SuppressWarnings("deprecation") public void modifiableImmutableCollections() { ModifiableMutableImmutableCollection m = ModifiableMutableImmutableCollection.create(); m.addA("a"); m.addA("b", "c"); m.addB("d", "e"); m.putC("x", 1); m.putC("y", 2); check(m.a()).isA(ImmutableCollection.class); check(m.b()).isA(ImmutableCollection.class); check(m.c()).isA(ImmutableMultimap.class); check(m.d()).isA(ImmutableMap.class); check(m.a()).isOf("a", "b", "c"); check(m.b()).isOf("d", "e"); check(m.c().values()).isOf(1, 2); check(m.c().keySet()).isOf("x", "y"); check(m.d().isEmpty()); m.clear(); check(m.a()).isEmpty(); check(m.b()).isEmpty(); check(m.c().entries()).isEmpty(); check(m.d().entrySet()).isEmpty(); }
/** * @param ijParamToCalleesMultimap Multimap from injected param key to transitive callees that * use the param. */ private IjParamsInfo(ImmutableMultimap<String, TemplateNode> ijParamToCalleesMultimap) { this.ijParamToCalleesMultimap = ijParamToCalleesMultimap; this.ijParamSet = ImmutableSortedSet.copyOf(ijParamToCalleesMultimap.keySet()); } }
/** * @param ijParamToCalleesMultimap Multimap from injected param key to transitive callees that * use the param. */ private IjParamsInfo(ImmutableMultimap<String, TemplateNode> ijParamToCalleesMultimap) { this.ijParamToCalleesMultimap = ijParamToCalleesMultimap; this.ijParamSet = ImmutableSortedSet.copyOf(ijParamToCalleesMultimap.keySet()); } }
@Override public String toString() { String classname = getClass().getSimpleName(); if (classname.length() < 5) { classname = MapFileHeader.class.getSimpleName(); } return String.format("%s{proofs=%s}", classname, proofs.keySet()); }
@SuppressWarnings("unchecked") public <T> Iterable<NamedComponent<T>> get(Factory.Query<T> key) { ImmutableCollection namedComponents = checkNotNull(materials.get(key), "key not found: %s. Check your bill of materials. Available keys: %s", key, materials.keySet()); return (Iterable<NamedComponent<T>>) namedComponents; }
public void writeToFile(Writer sb) throws IOException { for (V key : this.forward.keySet()) { for (VertexEntry<V, E> val : forward.get(key)) { sb.write(key.toString()); sb.write("\t"); sb.write(val.toString()); sb.write("\n"); } } sb.write("Verts: "); sb.write(this.getVertices().toString()); }
@Override public boolean test(@Nonnull final RequestArguments arguments) { return arguments.getHeaders().keySet().stream().anyMatch(conditionals::contains); }
@Override public boolean test(@Nonnull final RequestArguments arguments) { return arguments.getHeaders().keySet().stream().anyMatch("Idempotency-Key"::equalsIgnoreCase); }
@Override public boolean test(@Nonnull final RequestArguments arguments) { return arguments.getHeaders().keySet().stream().anyMatch("Idempotency-Key"::equalsIgnoreCase); }
@Override public boolean test(@Nonnull final RequestArguments arguments) { return arguments.getHeaders().keySet().stream().anyMatch(conditionals::contains); }
private ImmutableSet<DataNode> findRedundantNodes(IntermediateQuery query, InnerJoinNode joinNode, ImmutableMultimap<RelationDefinition, ExtensionalDataNode> dataNodeMap) { return dataNodeMap.keySet().stream() .flatMap(r -> r.getForeignKeys().stream() .flatMap(c -> selectRedundantNodesForConstraint(r, c, query, joinNode, dataNodeMap))) .collect(ImmutableCollectors.toSet()); }
private ImmutableSet<DataNode> findRedundantNodes(IntermediateQuery query, InnerJoinNode joinNode, ImmutableMultimap<DatabaseRelationDefinition, DataNode> dataNodeMap) { return dataNodeMap.keySet().stream() .flatMap(r -> r.getForeignKeys().stream() .flatMap(c -> selectRedundantNodesForConstraint(r, c, query, joinNode, dataNodeMap))) .collect(ImmutableCollectors.toSet()); }
private Headers toOkHeaders(ImmutableMultimap<String, String> headers) { Headers.Builder headersBuilder = new Headers.Builder(); for (String key : headers.keySet()) { for (String header : headers.get(key)) { headersBuilder.add(key, header); } } return headersBuilder.build(); }