Example usage for com.google.common.collect ImmutableSet.Builder addAll

Introduction

In this page you can find the example usage for com.google.common.collect ImmutableSet.Builder addAll.

Prototype

boolean addAll(Collection<? extends E> c);

Source Link

Document

Adds all of the elements in the specified collection to this set if they're not already present (optional operation).

Usage

From source file:com.facebook.buck.features.haskell.HaskellHaddockDescription.java

@Override
public BuildRule createBuildRule(BuildRuleCreationContextWithTargetGraph context, BuildTarget baseTarget,
        BuildRuleParams params, HaskellHaddockDescriptionArg args) {
    String name = baseTarget.getShortName();
    LOG.info("Creating Haddock " + name);

    ActionGraphBuilder graphBuilder = context.getActionGraphBuilder();
    SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(graphBuilder);
    HaskellPlatform platform = getPlatform(baseTarget, args);
    ImmutableCollection<BuildRule> deps = graphBuilder.getAllRules(args.getDeps());

    // Collect all Haskell deps
    ImmutableSet.Builder<HaskellHaddockInput> haddockInputs = ImmutableSet.builder();

    // Traverse all deps to pull packages + locations
    new AbstractBreadthFirstTraversal<BuildRule>(deps) {
        @Override/* w  ww  . ja  v  a 2  s  . c o  m*/
        public Iterable<BuildRule> visit(BuildRule rule) {
            ImmutableSet.Builder<BuildRule> traverse = ImmutableSet.builder();
            if (rule instanceof HaskellCompileDep) {
                HaskellCompileDep haskellCompileDep = (HaskellCompileDep) rule;

                // Only index first order dependencies
                if (deps.contains(rule)) {
                    haddockInputs.add(haskellCompileDep.getHaddockInput(platform));
                }

                traverse.addAll(haskellCompileDep.getCompileDeps(platform));
            }
            return traverse.build();
        }
    }.start();

    return graphBuilder.addToIndex(HaskellHaddockRule.from(baseTarget, context.getProjectFilesystem(), params,
            ruleFinder, platform.getHaddock().resolve(graphBuilder), args.getHaddockFlags(),
            haddockInputs.build()));
}

From source file:org.gradle.workers.internal.DefaultWorkerExecutor.java

private DaemonForkOptions toDaemonOptions(Class<?> actionClass, Iterable<Class<?>> paramClasses,
        JavaForkOptions userForkOptions, Iterable<File> classpath) {
    ImmutableSet.Builder<File> classpathBuilder = ImmutableSet.builder();
    ImmutableSet.Builder<String> sharedPackagesBuilder = ImmutableSet.builder();

    sharedPackagesBuilder.add("javax.inject");

    if (classpath != null) {
        classpathBuilder.addAll(classpath);
    }//from  w ww  . j ava  2  s  .  com

    addVisibilityFor(actionClass, classpathBuilder, sharedPackagesBuilder, true);

    for (Class<?> paramClass : paramClasses) {
        addVisibilityFor(paramClass, classpathBuilder, sharedPackagesBuilder, false);
    }

    Iterable<File> daemonClasspath = classpathBuilder.build();
    Iterable<String> daemonSharedPackages = sharedPackagesBuilder.build();

    JavaForkOptions forkOptions = new DefaultJavaForkOptions(fileResolver);
    userForkOptions.copyTo(forkOptions);
    forkOptions.setWorkingDir(workerDirectoryProvider.getIdleWorkingDirectory());

    return new DaemonForkOptionsBuilder(fileResolver).javaForkOptions(forkOptions).classpath(daemonClasspath)
            .sharedPackages(daemonSharedPackages).keepAliveMode(KeepAliveMode.DAEMON).build();
}

From source file:com.google.devtools.build.lib.util.GroupedList.java

@SuppressWarnings("unchecked")
public Set<T> toSet() {
    ImmutableSet.Builder<T> builder = ImmutableSet.builder();
    for (Object obj : elements) {
        if (obj instanceof List) {
            builder.addAll((List<T>) obj);
        } else {/*from  w  w  w.  jav a2 s .  c o m*/
            builder.add((T) obj);
        }
    }
    return builder.build();
}

From source file:org.javabits.yar.guice.SimpleRegistry.java

@Override
public Set<Id<?>> ids() {
    ImmutableSet.Builder<Id<?>> builder = ImmutableSet.builder();
    for (Type type : registrationContainer.types()) {
        builder.addAll(Lists.transform(getAll(TypeToken.of(type)), new Function<Supplier<?>, Id<?>>() {
            @Nullable//from  ww  w. j  av a  2  s. c o m
            @Override
            public Id<?> apply(@Nullable Supplier<?> supplier) {
                requireNonNull(supplier, "supplier");
                //noinspection ConstantConditions
                return supplier.id();
            }
        }));
    }
    return builder.build();
}

From source file:com.google.devtools.build.skyframe.SkyFunctionEnvironment.java

private Map<SkyKey, ? extends NodeEntry> batchPrefetch(SkyKey requestor, GroupedList<SkyKey> depKeys,
        Set<SkyKey> oldDeps, boolean assertDone, SkyKey keyForDebugging) throws InterruptedException {
    Iterable<SkyKey> depKeysAsIterable = Iterables.concat(depKeys);
    Iterable<SkyKey> keysToPrefetch = depKeysAsIterable;
    if (PREFETCH_OLD_DEPS) {
        ImmutableSet.Builder<SkyKey> keysToPrefetchBuilder = ImmutableSet.builder();
        keysToPrefetchBuilder.addAll(depKeysAsIterable).addAll(oldDeps);
        keysToPrefetch = keysToPrefetchBuilder.build();
    }/*  w w  w  .  j  a v a2s  .  c  o  m*/
    Map<SkyKey, ? extends NodeEntry> batchMap = evaluatorContext.getBatchValues(requestor, Reason.PREFETCH,
            keysToPrefetch);
    if (PREFETCH_OLD_DEPS) {
        batchMap = ImmutableMap.<SkyKey, NodeEntry>copyOf(
                Maps.filterKeys(batchMap, Predicates.in(ImmutableSet.copyOf(depKeysAsIterable))));
    }
    if (batchMap.size() != depKeys.numElements()) {
        throw new IllegalStateException("Missing keys for " + keyForDebugging + ": "
                + Sets.difference(depKeys.toSet(), batchMap.keySet()));
    }
    if (assertDone) {
        for (Map.Entry<SkyKey, ? extends NodeEntry> entry : batchMap.entrySet()) {
            Preconditions.checkState(entry.getValue().isDone(), "%s had not done %s", keyForDebugging, entry);
        }
    }
    return batchMap;
}

From source file:com.palantir.common.base.BatchingVisitableView.java

/**
 * Returns an immutable copy of the current contents of this iterable view. Does not support
 * null elements./* w  ww  .  j av  a 2s  .co m*/
 */
public ImmutableSet<T> immutableSetCopy() {
    final ImmutableSet.Builder<T> builder = ImmutableSet.builder();
    delegate().batchAccept(BatchingVisitables.KEEP_ALL_BATCH_SIZE,
            new AbortingVisitor<List<T>, RuntimeException>() {
                @Override
                public boolean visit(List<T> items) {
                    builder.addAll(items);
                    return true;
                }
            });
    return builder.build();
}

From source file:dagger.internal.codegen.BasicProcessor.java

private ImmutableSet<? extends Class<? extends Annotation>> getSupportedAnnotationClasses() {
    checkState(steps != null);/*from w w  w  . j  a  v  a 2  s . c om*/
    ImmutableSet.Builder<Class<? extends Annotation>> builder = ImmutableSet.builder();
    for (ProcessingStep step : steps) {
        builder.addAll(step.annotations());
    }
    return builder.build();
}

From source file:se.sics.caracaldb.global.DefaultPolicy.java

private void replaceFailedNodes(LUTWorkingBuffer lut, ImmutableSortedMap<Integer, Address> failIds,
        ImmutableSortedMap<Integer, Address> joinIds, ExtremeKMap<Double, Address> xKMemory,
        ExtremeKMap<Double, Address> xKCpu, ImmutableMap<Address, Stats.Report> stats) {

    TreeSet<Integer> idsToDealWith = new TreeSet<Integer>(failIds.keySet());
    TreeMultimap<Long, Integer> candidates = TreeMultimap.create();
    // If a node fails and rejoins immediately, assign the same id and don't touch 
    // its replicationSets, since it may still have data from before the failure
    for (Entry<Integer, Address> e : joinIds.entrySet()) {
        Address curNode = lut.lut.getHost(e.getKey());
        if (curNode.equals(e.getValue())) {
            idsToDealWith.remove(e.getKey());
            candidates.put(0l, e.getKey());
        }//from w w  w . j a v a2s.c om
    }
    // Add nodes with lowest resource usage to candidates
    ImmutableSet.Builder<Address> candidateAddrs = ImmutableSet.builder(); // still need to look up their ids
    candidateAddrs.addAll(xKMemory.bottom().values()).addAll(xKCpu.bottom().values()).build();
    Map<Address, Integer> candidateIds = lut.lut.getIdsForAddresses(candidateAddrs.build());
    for (Entry<Address, Integer> e : candidateIds.entrySet()) {
        Address addr = e.getKey();
        Integer id = e.getValue();
        Stats.Report rep = stats.get(addr);
        long curSize = rep.averageSize * rep.numberOfVNodes;
        candidates.put(curSize, id);
    }
    // Replace nodes in affected sets
    int index = 0;
    for (Integer[] member : lut.replicationSets()) {
        Integer[] newRepSet = Arrays.copyOf(member, member.length);
        for (int pos = 0; pos < member.length; pos++) {
            if (idsToDealWith.contains(member[pos])) {
                long lowestSize = candidates.keySet().first();
                if (lowestSize > averageHostSize) {
                    addMoreCandidates(lut, candidates, stats);
                }
                // pick the first (lowestSize) host not in the replicationSet
                long curSize = -1;
                long addedSize = -1;
                for (Entry<Long, Integer> e : candidates.entries()) {
                    if (LookupTable.positionInSet(newRepSet, e.getValue()) < 0) {
                        newRepSet[pos] = e.getValue();
                        curSize = e.getKey();
                        addedSize = guessAddedSize(lut, member, stats);
                        break;
                    }
                }
                if ((curSize < 0) || (addedSize < 0)) {
                    LOG.error("Could not find any candidate for replacing {} in replicationSet {}!",
                            member[pos], index);
                    continue;
                }
                // Update candidates
                candidates.remove(curSize, newRepSet[pos]);
                candidates.put(curSize + addedSize, newRepSet[pos]);
            }
        }
        if (!Arrays.equals(member, newRepSet)) {
            lut.putRepSet(index, newRepSet);
        }
        index++;
    }
}

From source file:com.google.inject.internal.ConstructorBindingImpl.java

/** Returns a set of dependencies that can be iterated over to clean up stray JIT bindings. */
Set<Dependency<?>> getInternalDependencies() {
    ImmutableSet.Builder<InjectionPoint> builder = ImmutableSet.builder();
    if (factory.constructorInjector == null) {
        builder.add(constructorInjectionPoint);
        // If the below throws, it's OK -- we just ignore those dependencies, because no one
        // could have used them anyway.
        try {//from   w  w w  .  j av a2 s .  c  om
            builder.addAll(
                    InjectionPoint.forInstanceMethodsAndFields(constructorInjectionPoint.getDeclaringType()));
        } catch (ConfigurationException ignored) {
        }
    } else {
        builder.add(getConstructor()).addAll(getInjectableMembers());
    }

    return Dependency.forInjectionPoints(builder.build());
}

From source file:io.prestosql.memory.ClusterMemoryManager.java

private synchronized void updateNodes(MemoryPoolAssignmentsRequest assignments) {
    ImmutableSet.Builder<Node> builder = ImmutableSet.builder();
    Set<Node> aliveNodes = builder.addAll(nodeManager.getNodes(ACTIVE))
            .addAll(nodeManager.getNodes(SHUTTING_DOWN)).build();

    ImmutableSet<String> aliveNodeIds = aliveNodes.stream().map(Node::getNodeIdentifier)
            .collect(toImmutableSet());/*w  w  w  .j  av a2s  . c  o  m*/

    // Remove nodes that don't exist anymore
    // Make a copy to materialize the set difference
    Set<String> deadNodes = ImmutableSet.copyOf(difference(nodes.keySet(), aliveNodeIds));
    nodes.keySet().removeAll(deadNodes);

    // Add new nodes
    for (Node node : aliveNodes) {
        if (!nodes.containsKey(node.getNodeIdentifier())) {
            nodes.put(node.getNodeIdentifier(), new RemoteNodeMemory(node, httpClient, memoryInfoCodec,
                    assignmentsRequestJsonCodec, locationFactory.createMemoryInfoLocation(node)));
        }
    }

    // If work isn't scheduled on the coordinator (the current node) there is no point
    // in polling or updating (when moving queries to the reserved pool) its memory pools
    if (!isWorkScheduledOnCoordinator) {
        nodes.remove(nodeManager.getCurrentNode().getNodeIdentifier());
    }

    // Schedule refresh
    for (RemoteNodeMemory node : nodes.values()) {
        node.asyncRefresh(assignments);
    }
}