@Override public void accept(Symbol symbol) { unusedImports.removeAll(importedSymbols.inverse().get(symbol)); } });
private boolean memberIsWhitelisted(Entry<String, ClassMemberKey> member) { return allowedMembers.containsEntry(member.getKey(), member.getValue()) || allowedMembers.get(member.getKey()).stream() .anyMatch( memberKey -> memberKey.descriptor().isEmpty() && memberKey.identifier().equals(member.getValue().identifier())); }
private ImmutableSet<Pipeline> selectPipelines(InterpreterListener interpreterListener, Set<Tuple2<String, String>> processingBlacklist, Message message, Set<String> initialStreamIds, ImmutableSetMultimap<String, Pipeline> streamConnection) { final String msgId = message.getId(); // if a message-stream combination has already been processed (is in the set), skip that execution final Set<String> streamsIds = initialStreamIds.stream() .filter(streamId -> !processingBlacklist.contains(tuple(msgId, streamId))) .filter(streamConnection::containsKey) .collect(Collectors.toSet()); final ImmutableSet<Pipeline> pipelinesToRun = streamsIds.stream() .flatMap(streamId -> streamConnection.get(streamId).stream()) .collect(ImmutableSet.toImmutableSet()); interpreterListener.processStreams(message, pipelinesToRun, streamsIds); log.debug("[{}] running pipelines {} for streams {}", msgId, pipelinesToRun, streamsIds); return pipelinesToRun; }
/** * Records which arguments are guaranteed to be non-null if the method completes without * exception. For example, if {@code checkNotNull(foo, message)} completes successfully, then * {@code foo} is not null. */ private static void setUnconditionalArgumentNullness( Updates bothUpdates, List<Node> arguments, ClassAndMethod callee) { Set<Integer> requiredNonNullParameters = REQUIRED_NON_NULL_PARAMETERS.get(callee.name()); for (LocalVariableNode var : variablesAtIndexes(requiredNonNullParameters, arguments)) { bothUpdates.set(var, NONNULL); } }
public void testBuilder_withImmutableEntry() { ImmutableSetMultimap<String, Integer> multimap = new Builder<String, Integer>().put(Maps.immutableEntry("one", 1)).build(); assertEquals(ImmutableSet.of(1), multimap.get("one")); }
MemberName calleeName = callee.name(); for (LocalVariableNode var : variablesAtIndexes(NULL_IMPLIES_TRUE_PARAMETERS.get(calleeName), arguments)) { elseUpdates.set(var, NONNULL); variablesAtIndexes(NONNULL_IFF_TRUE_PARAMETERS.get(calleeName), arguments)) { thenUpdates.set(var, NONNULL); elseUpdates.set(var, NULL); variablesAtIndexes(NULL_IFF_TRUE_PARAMETERS.get(calleeName), arguments)) { thenUpdates.set(var, NULL); elseUpdates.set(var, NONNULL);
public void testBuilder_withMutableEntry() { ImmutableSetMultimap.Builder<String, Integer> builder = new Builder<>(); final StringHolder holder = new StringHolder(); holder.string = "one"; Entry<String, Integer> entry = new AbstractMapEntry<String, Integer>() { @Override public String getKey() { return holder.string; } @Override public Integer getValue() { return 1; } }; builder.put(entry); holder.string = "two"; assertEquals(ImmutableSet.of(1), builder.build().get("one")); }
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); }
public void testBuilderOrderValuesBy() { ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); builder.put("b", 3); builder.put("d", 2); builder.put("a", 5); builder.orderValuesBy(Collections.reverseOrder()); builder.put("c", 4); builder.put("a", 2); builder.put("b", 6); ImmutableSetMultimap<String, Integer> multimap = builder.build(); assertThat(multimap.keySet()).containsExactly("b", "d", "a", "c").inOrder(); assertThat(multimap.values()).containsExactly(6, 3, 2, 5, 2, 4).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("b")).containsExactly(6, 3).inOrder(); assertTrue(multimap.get("a") instanceof ImmutableSortedSet); assertEquals( Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator()); assertTrue(multimap.get("x") instanceof ImmutableSortedSet); assertEquals( Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("x")).comparator()); assertTrue(multimap.asMap().get("a") instanceof ImmutableSortedSet); assertEquals( Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.asMap().get("a")).comparator()); }
public void testBuilderOrderKeysAndValuesBy() { ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); builder.put("b", 3); builder.put("d", 2); builder.put("a", 5); builder.orderKeysBy(Collections.reverseOrder()); builder.orderValuesBy(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, 6, 3, 5, 2).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("b")).containsExactly(6, 3).inOrder(); assertTrue(multimap.get("a") instanceof ImmutableSortedSet); assertEquals( Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator()); assertTrue(multimap.get("x") instanceof ImmutableSortedSet); assertEquals( Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("x")).comparator()); assertTrue(multimap.asMap().get("a") instanceof ImmutableSortedSet); assertEquals( Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.asMap().get("a")).comparator()); }
public void testBuilderOrderKeysByDuplicates() { ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); builder.put("bb", 3); builder.put("d", 2); builder.put("a", 5); builder.orderKeysBy( new Ordering<String>() { @Override public int compare(String left, String right) { return left.length() - right.length(); } }); builder.put("cc", 4); builder.put("a", 2); builder.put("bb", 6); ImmutableSetMultimap<String, Integer> multimap = builder.build(); assertThat(multimap.keySet()).containsExactly("d", "a", "bb", "cc").inOrder(); assertThat(multimap.values()).containsExactly(2, 5, 2, 3, 6, 4).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("bb")).containsExactly(3, 6).inOrder(); assertFalse(multimap.get("a") instanceof ImmutableSortedSet); assertFalse(multimap.get("x") instanceof ImmutableSortedSet); assertFalse(multimap.asMap().get("a") instanceof ImmutableSortedSet); }
@SuppressWarnings("CheckReturnValue") default void use() { ImmutableExtraCollection.of( ImmutableList.<String>of(), ImmutableMultimap.<Integer, String>of(), ImmutableMultimap.<Integer, String>of(), ImmutableMultimap.<Integer, String>of(), ImmutableBiMap.<Integer, String>of()); ImmutableExtraCollection.of(); ImmutableExtraCollection collection = ImmutableExtraCollection.builder() .addBag("2", "2") .putIndex(1, "2", "3", "4") .putAllIndex(1, Arrays.asList("2", "3", "4")) .putIndex(2, "5") .putIndexList(1, "") .putIndexSet(2, "2") .putAllIndexSet(2, Arrays.asList("3", "4")) .putBiMap(1, "a") .putBiMap(2, "b") .putAllBiMap(Collections.singletonMap(3, "c")) .build(); collection.bag().count("2"); collection.index().get(1); collection.indexList().get(1); collection.indexSet().get(2); } }
/** Converts a {@link ApiDiff} to a {@link ApiDiffProto.Diff}. */ public Diff toProto() { ApiDiffProto.Diff.Builder builder = ApiDiffProto.Diff.newBuilder(); for (String className : unsupportedClasses()) { builder.addClassDiff( ApiDiffProto.ClassDiff.newBuilder() .setEverythingDiff(ApiDiffProto.EverythingDiff.newBuilder().setClassName(className))); } for (String className : unsupportedMembersByClass().keySet()) { ApiDiffProto.MemberDiff.Builder memberDiff = ApiDiffProto.MemberDiff.newBuilder().setClassName(className); for (ClassMemberKey member : unsupportedMembersByClass().get(className)) { memberDiff.addMember( ApiDiffProto.ClassMember.newBuilder() .setIdentifier(member.identifier()) .setMemberDescriptor(member.descriptor())); } builder.addClassDiff(ApiDiffProto.ClassDiff.newBuilder().setMemberDiff(memberDiff)); } return builder.build(); } }
/** * Gets the set of users successfully granted accesses to the given application as result of the operation. * * @param application application, not null * @return set of usernames, never null */ public Set<String> getSuccessful(SupportedApplication application) { return successful.get(application); }
@Override public Set<E> getEdgesFrom(V src) { return sources.get(src); }
/** * Returns the set of the cluster broadcast points. * * @param clusterId cluster identifier * @return set of cluster broadcast points */ public Set<ConnectPoint> broadcastPoints(ClusterId clusterId) { return broadcastSets.get().get(clusterId); }
@Nonnull public Set<String> getProjectKeys(final Long projectId) { return projectKeys.get(projectId); }
/** * Returns the {@link SubcomponentDeclaration}s that match the {@code key} from this and all * ancestor resolvers. */ private ImmutableSet<SubcomponentDeclaration> getSubcomponentDeclarations(Key key) { ImmutableSet.Builder<SubcomponentDeclaration> subcomponentDeclarations = ImmutableSet.builder(); for (Resolver resolver : getResolverLineage()) { subcomponentDeclarations.addAll(resolver.subcomponentDeclarations.get(key)); } return subcomponentDeclarations.build(); } /**
private boolean memberIsWhitelisted(Entry<String, ClassMemberKey> member) { return allowedMembers.containsEntry(member.getKey(), member.getValue()) || allowedMembers.get(member.getKey()).stream() .anyMatch( memberKey -> memberKey.descriptor().isEmpty() && memberKey.identifier().equals(member.getValue().identifier())); }
/** * Records which arguments are guaranteed to be non-null if the method completes without * exception. For example, if {@code checkNotNull(foo, message)} completes successfully, then * {@code foo} is not null. */ private static void setUnconditionalArgumentNullness( Updates bothUpdates, List<Node> arguments, ClassAndMethod callee) { Set<Integer> requiredNonNullParameters = REQUIRED_NON_NULL_PARAMETERS.get(callee.name()); for (LocalVariableNode var : variablesAtIndexes(requiredNonNullParameters, arguments)) { bothUpdates.set(var, NONNULL); } }