/** * Returns an immutable set containing each of {@code elements}, minus duplicates, in the order * each appears first in the source iterator. * * @throws NullPointerException if any of {@code elements} is null */ public static <E> ImmutableSet<E> copyOf(Iterator<? extends E> elements) { // We special-case for 0 or 1 elements, but anything further is madness. if (!elements.hasNext()) { return of(); } E first = elements.next(); if (!elements.hasNext()) { return of(first); } else { return new ImmutableSet.Builder<E>().add(first).addAll(elements).build(); } }
@Override public ImmutableSet<E> immutableCopy() { return new ImmutableSet.Builder<E>().addAll(set1).addAll(set2).build(); } };
CorsConfig(CorsServiceBuilder builder) { enabled = true; anyOriginSupported = builder.anyOriginSupported; shortCircuit = builder.shortCircuit; policies = new ImmutableSet.Builder<CorsPolicy>() .add(builder.firstPolicyBuilder.build()) .addAll(builder.policies) .addAll(builder.policyBuilders.stream().map(AbstractCorsPolicyBuilder::build) .collect(Collectors.toSet())) .build(); }
public void fetchTransformDeps() { DependencyCache dependencyCache = new DependencyCache(rootProject, ProjectUtil.getDependencyManager(rootProject)); Scope transformScope = Scope.builder(rootProject) .configuration(CONFIGURATION_TRANSFORM) .depCache(dependencyCache) .build(); dependencies = new ImmutableSet.Builder<String>() .addAll(BuckRuleComposer.targets(transformScope.getTargetDeps())) .addAll(BuckRuleComposer.external(transformScope.getExternalDeps())) .add(TRANSFORM_JAR_RULE) .build(); }
/** * Returns a new builder, expecting the specified number of distinct elements to be added. * * <p>If {@code expectedSize} is exactly the number of distinct elements added to the builder * before {@link Builder#build} is called, the builder is likely to perform better than an unsized * {@link #builder()} would have. * * <p>It is not specified if any performance benefits apply if {@code expectedSize} is close to, * but not exactly, the number of distinct elements added to the builder. * * @since 23.1 */ @Beta public static <E> Builder<E> builderWithExpectedSize(int expectedSize) { checkNonnegative(expectedSize, "expectedSize"); return new Builder<E>(expectedSize); }
private List<Pattern> getExcludePatterns() { if (excludePatterns == null) { excludePatterns = new ImmutableSet.Builder<String>() .addAll(exclude) .addAll(JETIFIER_DEPS) .build() .stream() .map(Pattern::compile) .collect(Collectors.toList()); } return excludePatterns; }
@Nullable public String getConsumerProguardConfig() { Set<File> consumerProguardFiles = new ImmutableSet.Builder<File>() .addAll(getBaseVariant().getMergedFlavor().getConsumerProguardFiles()) .addAll(getBaseVariant().getBuildType().getConsumerProguardFiles()) .build(); if (consumerProguardFiles.size() > 0) { Optional<File> optionalFile = consumerProguardFiles.stream().findFirst(); return FileUtil.getRelativePath(getProject().getProjectDir(), optionalFile.get()); } return null; }
/** * Returns a new builder, expecting the specified number of distinct elements to be added. * * <p>If {@code expectedSize} is exactly the number of distinct elements added to the builder * before {@link Builder#build} is called, the builder is likely to perform better than an unsized * {@link #builder()} would have. * * <p>It is not specified if any performance benefits apply if {@code expectedSize} is close to, * but not exactly, the number of distinct elements added to the builder. * * @since 23.1 */ @Beta public static <E> Builder<E> builderWithExpectedSize(int expectedSize) { checkNonnegative(expectedSize, "expectedSize"); return new Builder<E>(expectedSize); }
private static <V> ImmutableSet.Builder<V> valuesBuilder( @NullableDecl Comparator<? super V> valueComparator) { return (valueComparator == null) ? new ImmutableSet.Builder<V>() : new ImmutableSortedSet.Builder<V>(valueComparator); }
@Override public ContainerBuilder<ImmutableSet<?>> newContainerBuilderFor(Class<?> type) { return new ContainerBuilder<ImmutableSet<?>>() { final ImmutableSet.Builder<Object> builder = new ImmutableSet.Builder<>(); @Override public ContainerBuilder<ImmutableSet<?>> add(final Object obj) { builder.add(obj); return this; } @Override public ImmutableSet<?> build() { return builder.build(); } }; } }
/** * Returns a new builder. The generated builder is equivalent to the builder created by the {@link * Builder} constructor. */ public static <E> Builder<E> builder() { return new Builder<E>(); }
@Override public ImmutableSet<E> immutableCopy() { return new ImmutableSet.Builder<E>().addAll(set1).addAll(set2).build(); } };
private static LibraryModels loadLibraryModels() { Iterable<LibraryModels> externalLibraryModels = ServiceLoader.load(LibraryModels.class, LibraryModels.class.getClassLoader()); ImmutableSet.Builder<LibraryModels> libModelsBuilder = new ImmutableSet.Builder<>(); libModelsBuilder.add(new DefaultLibraryModels()).addAll(externalLibraryModels); return new CombinedLibraryModels(libModelsBuilder.build()); }
@Override public Set<Dependency<?>> getDependencies() { return Dependency.forInjectionPoints( new ImmutableSet.Builder<InjectionPoint>() .add(getConstructor()) .addAll(getInjectableMembers()) .build()); }
/** * Returns a new builder. The generated builder is equivalent to the builder created by the {@link * Builder} constructor. */ public static <E> Builder<E> builder() { return new Builder<E>(); }
@Override public ImmutableSet<E> immutableCopy() { return new ImmutableSet.Builder<E>().addAll(set1).addAll(set2).build(); } };
public Set<String> getAllTiers() { ImmutableSet.Builder<String> builder = new ImmutableSet.Builder<>(); druidNodeDiscovery.getAllNodes().forEach( node -> builder.add(((LookupNodeService) node.getServices() .get(LookupNodeService.DISCOVERY_SERVICE_KEY)).getLookupTier()) ); return builder.build(); } }
/** * Returns a new builder, expecting the specified number of distinct elements to be added. * * <p>If {@code expectedSize} is exactly the number of distinct elements added to the builder * before {@link Builder#build} is called, the builder is likely to perform better than an unsized * {@link #builder()} would have. * * <p>It is not specified if any performance benefits apply if {@code expectedSize} is close to, * but not exactly, the number of distinct elements added to the builder. * * @since 23.1 */ @Beta public static <E> Builder<E> builderWithExpectedSize(int expectedSize) { checkNonnegative(expectedSize, "expectedSize"); return new Builder<E>(expectedSize); }
private static <V> ImmutableSet.Builder<V> valuesBuilder( @Nullable Comparator<? super V> valueComparator) { return (valueComparator == null) ? new ImmutableSet.Builder<V>() : new ImmutableSortedSet.Builder<V>(valueComparator); }
/** * Returns a new builder. The generated builder is equivalent to the builder created by the {@link * Builder} constructor. */ public static <E> Builder<E> builder() { return new Builder<E>(); }