Example usage for com.google.common.collect ImmutableSetMultimap builder

List of usage examples for com.google.common.collect ImmutableSetMultimap builder

Introduction

In this page you can find the example usage for com.google.common.collect ImmutableSetMultimap builder.

Prototype

public static <K, V> Builder<K, V> builder() 

Source Link

Document

Returns a new Builder .

Usage

From source file:org.jdbi.v3.guava.GuavaCollectors.java

/**
 * Returns a {@code Collector} that accumulates {@code Map.Entry<K, V>} input elements into an
 * {@code ImmutableSetMultimap<K, V>}.
 *
 * @param <K> the type of map keys
 * @param <V> the type of map values
 * @return a {@code Collector} which collects map entry elements into an {@code ImmutableSetMultimap},
 * in encounter order.//w  w  w .  j  a v  a2 s.  c om
 */
public static <K, V> Collector<Map.Entry<K, V>, ?, ImmutableSetMultimap<K, V>> toImmutableSetMultimap() {
    return Collector.of(ImmutableSetMultimap::<K, V>builder, ImmutableSetMultimap.Builder::put,
            GuavaCollectors::combine, ImmutableSetMultimap.Builder::build);
}

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

/**
 * Groups {@code binding}'s implicit dependencies by their binding key, using the dependency keys
 * from the {@link Binding#unresolved()} binding if it exists.
 *///ww  w.  j a v a 2  s .  c om
private ImmutableList<Collection<DependencyRequest>> groupByUnresolvedKey() {
    ImmutableSetMultimap.Builder<BindingKey, 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().bindingKey(), dependencies.next());
    }
    return ImmutableList.copyOf(
            dependenciesByKeyBuilder.orderValuesBy(SourceFiles.DEPENDENCY_ORDERING).build().asMap().values());
}

From source file:com.facebook.buck.apple.WorkspaceAndProjectGenerator.java

public Path generateWorkspaceAndDependentProjects(Map<Path, ProjectGenerator> projectGenerators)
        throws IOException {
    LOG.debug("Generating workspace for target %s", workspaceBuildTarget);

    String workspaceName = XcodeWorkspaceConfigDescription.getWorkspaceNameFromArg(workspaceArguments);
    Path outputDirectory;/*w  w w  .j  a  v a2s  .com*/
    if (combinedProject) {
        workspaceName += "-Combined";
        outputDirectory = BuildTargets.getGenPath(workspaceBuildTarget, "%s").getParent()
                .resolve(workspaceName + ".xcodeproj");
    } else {
        outputDirectory = workspaceBuildTarget.getBasePath();
    }

    WorkspaceGenerator workspaceGenerator = new WorkspaceGenerator(projectFilesystem,
            combinedProject ? "project" : workspaceName, outputDirectory);

    ImmutableMap.Builder<String, XcodeWorkspaceConfigDescription.Arg> schemeConfigsBuilder = ImmutableMap
            .builder();
    ImmutableSetMultimap.Builder<String, Optional<TargetNode<?>>> schemeNameToSrcTargetNodeBuilder = ImmutableSetMultimap
            .builder();
    ImmutableSetMultimap.Builder<String, TargetNode<?>> buildForTestNodesBuilder = ImmutableSetMultimap
            .builder();
    ImmutableMultimap.Builder<AppleTestBundleParamsKey, TargetNode<AppleTestDescription.Arg>> groupedTestsBuilder = ImmutableMultimap
            .builder();
    ImmutableSetMultimap.Builder<String, TargetNode<AppleTestDescription.Arg>> ungroupedTestsBuilder = ImmutableSetMultimap
            .builder();

    buildWorkspaceSchemes(getTargetToBuildWithBuck(), projectGraph,
            projectGeneratorOptions.contains(ProjectGenerator.Option.INCLUDE_TESTS),
            projectGeneratorOptions.contains(ProjectGenerator.Option.INCLUDE_DEPENDENCIES_TESTS),
            groupableTests, workspaceName, workspaceArguments, schemeConfigsBuilder,
            schemeNameToSrcTargetNodeBuilder, buildForTestNodesBuilder, groupedTestsBuilder,
            ungroupedTestsBuilder);

    ImmutableMap<String, XcodeWorkspaceConfigDescription.Arg> schemeConfigs = schemeConfigsBuilder.build();
    ImmutableSetMultimap<String, Optional<TargetNode<?>>> schemeNameToSrcTargetNode = schemeNameToSrcTargetNodeBuilder
            .build();
    ImmutableSetMultimap<String, TargetNode<?>> buildForTestNodes = buildForTestNodesBuilder.build();
    ImmutableMultimap<AppleTestBundleParamsKey, TargetNode<AppleTestDescription.Arg>> groupedTests = groupedTestsBuilder
            .build();
    ImmutableSetMultimap<String, TargetNode<AppleTestDescription.Arg>> ungroupedTests = ungroupedTestsBuilder
            .build();
    Iterable<PBXTarget> synthesizedCombinedTestTargets = ImmutableList.of();

    ImmutableSet<BuildTarget> targetsInRequiredProjects = FluentIterable
            .from(Optional.presentInstances(schemeNameToSrcTargetNode.values()))
            .append(buildForTestNodes.values()).transform(HasBuildTarget.TO_TARGET).toSet();
    ImmutableMultimap.Builder<BuildTarget, PBXTarget> buildTargetToPbxTargetMapBuilder = ImmutableMultimap
            .builder();
    ImmutableMap.Builder<PBXTarget, Path> targetToProjectPathMapBuilder = ImmutableMap.builder();
    Optional<BuildTarget> targetToBuildWithBuck = getTargetToBuildWithBuck();

    if (combinedProject) {
        LOG.debug("Generating a combined project");
        ProjectGenerator generator = new ProjectGenerator(projectGraph, targetsInRequiredProjects,
                projectFilesystem, outputDirectory.getParent(), workspaceName, buildFileName,
                projectGeneratorOptions, targetToBuildWithBuck, buildWithBuckFlags, executableFinder,
                environment, cxxPlatforms, defaultCxxPlatform, sourcePathResolverForNode, buckEventBus,
                attemptToDetermineBestCxxPlatform, halideBuckConfig, cxxBuckConfig)
                        .setAdditionalCombinedTestTargets(groupedTests)
                        .setTestsToGenerateAsStaticLibraries(groupableTests);
        combinedProjectGenerator = Optional.of(generator);
        generator.createXcodeProjects();

        workspaceGenerator.addFilePath(generator.getProjectPath(), Optional.<Path>absent());
        requiredBuildTargetsBuilder.addAll(generator.getRequiredBuildTargets());

        buildTargetToPbxTargetMapBuilder.putAll(generator.getBuildTargetToGeneratedTargetMap());
        for (PBXTarget target : generator.getBuildTargetToGeneratedTargetMap().values()) {
            targetToProjectPathMapBuilder.put(target, generator.getProjectPath());
        }
        synthesizedCombinedTestTargets = generator.getBuildableCombinedTestTargets();
        for (PBXTarget target : synthesizedCombinedTestTargets) {
            targetToProjectPathMapBuilder.put(target, generator.getProjectPath());
        }
    } else {
        ImmutableMultimap.Builder<Path, BuildTarget> projectDirectoryToBuildTargetsBuilder = ImmutableMultimap
                .builder();
        for (TargetNode<?> targetNode : projectGraph.getNodes()) {
            BuildTarget buildTarget = targetNode.getBuildTarget();
            projectDirectoryToBuildTargetsBuilder.put(buildTarget.getBasePath(), buildTarget);
        }
        ImmutableMultimap<Path, BuildTarget> projectDirectoryToBuildTargets = projectDirectoryToBuildTargetsBuilder
                .build();
        for (Path projectDirectory : projectDirectoryToBuildTargets.keySet()) {
            final ImmutableSet<BuildTarget> rules = filterRulesForProjectDirectory(projectGraph,
                    ImmutableSet.copyOf(projectDirectoryToBuildTargets.get(projectDirectory)));
            if (Sets.intersection(targetsInRequiredProjects, rules).isEmpty()) {
                continue;
            }

            ProjectGenerator generator = projectGenerators.get(projectDirectory);
            if (generator == null) {
                LOG.debug("Generating project for directory %s with targets %s", projectDirectory, rules);
                String projectName;
                if (projectDirectory.getNameCount() == 0) {
                    // If we're generating a project in the root directory, use a generic name.
                    projectName = "Project";
                } else {
                    // Otherwise, name the project the same thing as the directory we're in.
                    projectName = projectDirectory.getFileName().toString();
                }
                generator = new ProjectGenerator(projectGraph, rules, projectFilesystem, projectDirectory,
                        projectName, buildFileName, projectGeneratorOptions, Optionals.bind(
                                targetToBuildWithBuck, new Function<BuildTarget, Optional<BuildTarget>>() {
                                    @Override
                                    public Optional<BuildTarget> apply(BuildTarget input) {
                                        return rules.contains(input) ? Optional.of(input)
                                                : Optional.<BuildTarget>absent();
                                    }
                                }),
                        buildWithBuckFlags, executableFinder, environment, cxxPlatforms, defaultCxxPlatform,
                        sourcePathResolverForNode, buckEventBus, attemptToDetermineBestCxxPlatform,
                        halideBuckConfig, cxxBuckConfig).setTestsToGenerateAsStaticLibraries(groupableTests);

                generator.createXcodeProjects();
                requiredBuildTargetsBuilder.addAll(generator.getRequiredBuildTargets());
                projectGenerators.put(projectDirectory, generator);
            } else {
                LOG.debug("Already generated project for target %s, skipping", projectDirectory);
            }

            workspaceGenerator.addFilePath(generator.getProjectPath());

            buildTargetToPbxTargetMapBuilder.putAll(generator.getBuildTargetToGeneratedTargetMap());
            for (PBXTarget target : generator.getBuildTargetToGeneratedTargetMap().values()) {
                targetToProjectPathMapBuilder.put(target, generator.getProjectPath());
            }
        }

        if (!groupedTests.isEmpty()) {
            ProjectGenerator combinedTestsProjectGenerator = new ProjectGenerator(projectGraph,
                    ImmutableSortedSet.<BuildTarget>of(), projectFilesystem,
                    BuildTargets.getGenPath(workspaceBuildTarget, "%s-CombinedTestBundles"),
                    "_CombinedTestBundles", buildFileName, projectGeneratorOptions,
                    Optional.<BuildTarget>absent(), buildWithBuckFlags, executableFinder, environment,
                    cxxPlatforms, defaultCxxPlatform, sourcePathResolverForNode, buckEventBus,
                    attemptToDetermineBestCxxPlatform, halideBuckConfig, cxxBuckConfig);
            combinedTestsProjectGenerator.setAdditionalCombinedTestTargets(groupedTests).createXcodeProjects();
            workspaceGenerator.addFilePath(combinedTestsProjectGenerator.getProjectPath());
            requiredBuildTargetsBuilder.addAll(combinedTestsProjectGenerator.getRequiredBuildTargets());
            for (PBXTarget target : combinedTestsProjectGenerator.getBuildTargetToGeneratedTargetMap()
                    .values()) {
                targetToProjectPathMapBuilder.put(target, combinedTestsProjectGenerator.getProjectPath());
            }
            synthesizedCombinedTestTargets = combinedTestsProjectGenerator.getBuildableCombinedTestTargets();
            for (PBXTarget target : synthesizedCombinedTestTargets) {
                targetToProjectPathMapBuilder.put(target, combinedTestsProjectGenerator.getProjectPath());
            }
            this.combinedTestsProjectGenerator = Optional.of(combinedTestsProjectGenerator);
        }
    }

    Path workspacePath = workspaceGenerator.writeWorkspace();

    final Multimap<BuildTarget, PBXTarget> buildTargetToTarget = buildTargetToPbxTargetMapBuilder.build();
    final Function<BuildTarget, PBXTarget> targetNodeToPBXTargetTransformer = new Function<BuildTarget, PBXTarget>() {
        @Override
        public PBXTarget apply(BuildTarget input) {
            ImmutableList<PBXTarget> targets = ImmutableList.copyOf(buildTargetToTarget.get(input));
            if (targets.size() == 1) {
                return targets.get(0);
            }
            // The only reason why a build target would map to more than one project target is if
            // there are two project targets: one is the usual one, the other is a target that just
            // shells out to Buck.
            Preconditions.checkState(targets.size() == 2);
            PBXTarget first = targets.get(0);
            PBXTarget second = targets.get(1);
            Preconditions.checkState(first.getName().endsWith(ProjectGenerator.BUILD_WITH_BUCK_POSTFIX)
                    ^ second.getName().endsWith(ProjectGenerator.BUILD_WITH_BUCK_POSTFIX));
            PBXTarget buildWithBuckTarget;
            PBXTarget buildWithXcodeTarget;
            if (first.getName().endsWith(ProjectGenerator.BUILD_WITH_BUCK_POSTFIX)) {
                buildWithBuckTarget = first;
                buildWithXcodeTarget = second;
            } else {
                buildWithXcodeTarget = first;
                buildWithBuckTarget = second;
            }
            return buildWithBuck ? buildWithBuckTarget : buildWithXcodeTarget;
        }
    };

    writeWorkspaceSchemes(workspaceName, outputDirectory, schemeConfigs, schemeNameToSrcTargetNode,
            buildForTestNodes, ungroupedTests, targetToProjectPathMapBuilder.build(),
            synthesizedCombinedTestTargets, new Function<TargetNode<?>, Collection<PBXTarget>>() {
                @Override
                public Collection<PBXTarget> apply(TargetNode<?> input) {
                    return buildTargetToTarget.get(input.getBuildTarget());
                }
            }, targetNodeToPBXTargetTransformer);

    return workspacePath;
}

From source file:org.glowroot.container.trace.Trace.java

@JsonCreator
static Trace readValue(@JsonProperty("id") @Nullable String id,
        @JsonProperty("active") @Nullable Boolean active, @JsonProperty("partial") @Nullable Boolean partial,
        @JsonProperty("error") @Nullable Boolean error, @JsonProperty("startTime") @Nullable Long startTime,
        @JsonProperty("captureTime") @Nullable Long captureTime,
        @JsonProperty("duration") @Nullable Long duration,
        @JsonProperty("transactionType") @Nullable String transactionType,
        @JsonProperty("transactionName") @Nullable String transactionName,
        @JsonProperty("headline") @Nullable String headline, @JsonProperty("user") @Nullable String user,
        @JsonProperty("customAttributes") @Nullable Map<String, /*@Nullable*/List</*@Nullable*/String>> customAttributes,
        @JsonProperty("customDetail") @Nullable Map<String, /*@Nullable*/Object> customDetail,
        @JsonProperty("errorMessage") @Nullable String errorMessage,
        @JsonProperty("errorThrowable") @Nullable ThrowableInfo errorThrowable,
        @JsonProperty("timers") @Nullable Timer rootTimer,
        @JsonProperty("threadCpuTime") @Nullable Long threadCpuTime,
        @JsonProperty("threadBlockedTime") @Nullable Long threadBlockedTime,
        @JsonProperty("threadWaitedTime") @Nullable Long threadWaitedTime,
        @JsonProperty("threadAllocatedBytes") @Nullable Long threadAllocatedBytes,
        @JsonProperty("gcInfos") @Nullable List</*@Nullable*/TraceGcInfo> gcInfosUnchecked,
        @JsonProperty("entryCount") @Nullable Long entryCount,
        @JsonProperty("profileSampleCount") @Nullable Long profileSampleCount,
        @JsonProperty("entriesExistence") @Nullable Existence entriesExistence,
        @JsonProperty("profileExistence") @Nullable Existence profileExistence) throws JsonMappingException {
    List<TraceGcInfo> gcInfos = orEmpty(gcInfosUnchecked, "gcInfos");
    checkRequiredProperty(id, "id");
    checkRequiredProperty(active, "active");
    checkRequiredProperty(partial, "partial");
    checkRequiredProperty(error, "error");
    checkRequiredProperty(startTime, "startTime");
    checkRequiredProperty(captureTime, "captureTime");
    checkRequiredProperty(duration, "duration");
    checkRequiredProperty(transactionType, "transactionType");
    checkRequiredProperty(transactionName, "transactionName");
    checkRequiredProperty(headline, "headline");
    checkRequiredProperty(rootTimer, "timers");
    checkRequiredProperty(entryCount, "entryCount");
    checkRequiredProperty(profileSampleCount, "profileSampleCount");
    checkRequiredProperty(entriesExistence, "entriesExistence");
    checkRequiredProperty(profileExistence, "profileExistence");
    ImmutableSetMultimap.Builder<String, String> theCustomAttributes = ImmutableSetMultimap.builder();
    if (customAttributes != null) {
        for (Entry<String, /*@Nullable*/List</*@Nullable*/String>> entry : customAttributes.entrySet()) {
            List</*@Nullable*/String> uncheckedValues = entry.getValue();
            if (uncheckedValues == null) {
                throw new JsonMappingException("Null value not allowed for custom attribute map value");
            }//  w  w w . ja v  a2s .  c  o  m
            List<String> values = orEmpty(uncheckedValues, "customAttributes");
            theCustomAttributes.putAll(entry.getKey(), values);
        }
    }
    return new Trace(id, active, partial, error, startTime, captureTime, duration, transactionType,
            transactionName, headline, user, theCustomAttributes.build(), nullToEmpty(customDetail),
            errorMessage, errorThrowable, rootTimer, threadCpuTime, threadBlockedTime, threadWaitedTime,
            threadAllocatedBytes, gcInfos, entryCount, profileSampleCount, entriesExistence, profileExistence);
}

From source file:com.facebook.buck.apple.project_generator.WorkspaceAndProjectGenerator.java

public Path generateWorkspaceAndDependentProjects(Map<Path, ProjectGenerator> projectGenerators,
        ListeningExecutorService listeningExecutorService) throws IOException, InterruptedException {
    LOG.debug("Generating workspace for target %s", workspaceBuildTarget);

    String workspaceName = XcodeWorkspaceConfigDescription.getWorkspaceNameFromArg(workspaceArguments);
    Path outputDirectory;/* w  w w.j  av  a 2s.co  m*/
    if (combinedProject) {
        workspaceName += "-Combined";
        outputDirectory = BuildTargets.getGenPath(rootCell.getFilesystem(), workspaceBuildTarget, "%s")
                .getParent().resolve(workspaceName + ".xcodeproj");
    } else {
        outputDirectory = workspaceBuildTarget.getBasePath();
    }

    WorkspaceGenerator workspaceGenerator = new WorkspaceGenerator(rootCell.getFilesystem(),
            combinedProject ? "project" : workspaceName, outputDirectory);

    ImmutableMap.Builder<String, XcodeWorkspaceConfigDescription.Arg> schemeConfigsBuilder = ImmutableMap
            .builder();
    ImmutableSetMultimap.Builder<String, Optional<TargetNode<?, ?>>> schemeNameToSrcTargetNodeBuilder = ImmutableSetMultimap
            .builder();
    ImmutableSetMultimap.Builder<String, TargetNode<?, ?>> buildForTestNodesBuilder = ImmutableSetMultimap
            .builder();
    ImmutableSetMultimap.Builder<String, TargetNode<AppleTestDescription.Arg, ?>> testsBuilder = ImmutableSetMultimap
            .builder();

    buildWorkspaceSchemes(projectGraph, projectGeneratorOptions.contains(ProjectGenerator.Option.INCLUDE_TESTS),
            projectGeneratorOptions.contains(ProjectGenerator.Option.INCLUDE_DEPENDENCIES_TESTS), workspaceName,
            workspaceArguments, schemeConfigsBuilder, schemeNameToSrcTargetNodeBuilder,
            buildForTestNodesBuilder, testsBuilder);

    ImmutableMap<String, XcodeWorkspaceConfigDescription.Arg> schemeConfigs = schemeConfigsBuilder.build();
    ImmutableSetMultimap<String, Optional<TargetNode<?, ?>>> schemeNameToSrcTargetNode = schemeNameToSrcTargetNodeBuilder
            .build();
    ImmutableSetMultimap<String, TargetNode<?, ?>> buildForTestNodes = buildForTestNodesBuilder.build();
    ImmutableSetMultimap<String, TargetNode<AppleTestDescription.Arg, ?>> tests = testsBuilder.build();

    ImmutableSet<BuildTarget> targetsInRequiredProjects = Stream
            .concat(schemeNameToSrcTargetNode.values().stream().flatMap(Optionals::toStream),
                    buildForTestNodes.values().stream())
            .map(HasBuildTarget::getBuildTarget).collect(MoreCollectors.toImmutableSet());
    ImmutableMultimap.Builder<BuildTarget, PBXTarget> buildTargetToPbxTargetMapBuilder = ImmutableMultimap
            .builder();
    ImmutableMap.Builder<PBXTarget, Path> targetToProjectPathMapBuilder = ImmutableMap.builder();
    Optional<BuildTarget> targetToBuildWithBuck = getTargetToBuildWithBuck();
    generateProjects(projectGenerators, listeningExecutorService, workspaceName, outputDirectory,
            workspaceGenerator, targetsInRequiredProjects, buildTargetToPbxTargetMapBuilder,
            targetToProjectPathMapBuilder, targetToBuildWithBuck);
    final Multimap<BuildTarget, PBXTarget> buildTargetToTarget = buildTargetToPbxTargetMapBuilder.build();

    writeWorkspaceSchemes(workspaceName, outputDirectory, schemeConfigs, schemeNameToSrcTargetNode,
            buildForTestNodes, tests, targetToProjectPathMapBuilder.build(),
            input -> buildTargetToTarget.get(input.getBuildTarget()),
            getTargetNodeToPBXTargetTransformFunction(buildTargetToTarget, buildWithBuck));

    return workspaceGenerator.writeWorkspace();
}

From source file:com.facebook.buck.java.DefaultJavaLibraryRule.java

protected DefaultJavaLibraryRule(BuildRuleParams buildRuleParams, Set<String> srcs,
        Set<? extends SourcePath> resources, Optional<String> proguardConfig, Set<BuildRule> exportedDeps,
        JavacOptions javacOptions) {/*from ww w.  ja  v a  2s  .  co m*/
    super(buildRuleParams);
    this.srcs = ImmutableSortedSet.copyOf(srcs);
    this.resources = ImmutableSortedSet.copyOf(resources);
    this.proguardConfig = Preconditions.checkNotNull(proguardConfig);
    this.exportedDeps = ImmutableSortedSet.copyOf(exportedDeps);
    this.javacOptions = Preconditions.checkNotNull(javacOptions);

    if (!srcs.isEmpty() || !resources.isEmpty()) {
        this.outputJar = Optional.of(getOutputJarPath(getBuildTarget()));
    } else {
        this.outputJar = Optional.absent();
    }

    // Note that both srcs and resources are sorted so that the list order is consistent even if
    // the iteration order of the sets passed to the constructor changes. See
    // AbstractBuildRule.getInputsToCompareToOutput() for details.
    ImmutableList.Builder<String> builder = ImmutableList.<String>builder().addAll(this.srcs);
    builder.addAll(SourcePaths.filterInputsToCompareToOutput(resources));
    inputsToConsiderForCachingPurposes = builder.build();

    outputClasspathEntriesSupplier = Suppliers
            .memoize(new Supplier<ImmutableSetMultimap<JavaLibraryRule, String>>() {
                @Override
                public ImmutableSetMultimap<JavaLibraryRule, String> get() {
                    ImmutableSetMultimap.Builder<JavaLibraryRule, String> outputClasspathBuilder = ImmutableSetMultimap
                            .builder();
                    Iterable<JavaLibraryRule> javaExportedLibraryDeps = Iterables.filter(getExportedDeps(),
                            JavaLibraryRule.class);

                    for (JavaLibraryRule rule : javaExportedLibraryDeps) {
                        outputClasspathBuilder.putAll(rule, rule.getOutputClasspathEntries().values());
                        // If we have any exported deps, add an entry mapping ourselves to to their,
                        // classpaths so when suggesting libraries to add we know that adding this library
                        // would pull in it's deps.
                        outputClasspathBuilder.putAll(DefaultJavaLibraryRule.this,
                                rule.getOutputClasspathEntries().values());
                    }

                    if (outputJar.isPresent()) {
                        outputClasspathBuilder.put(DefaultJavaLibraryRule.this, getPathToOutputFile());
                    }

                    return outputClasspathBuilder.build();
                }
            });

    transitiveClasspathEntriesSupplier = Suppliers
            .memoize(new Supplier<ImmutableSetMultimap<JavaLibraryRule, String>>() {
                @Override
                public ImmutableSetMultimap<JavaLibraryRule, String> get() {
                    final ImmutableSetMultimap.Builder<JavaLibraryRule, String> classpathEntries = ImmutableSetMultimap
                            .builder();
                    ImmutableSetMultimap<JavaLibraryRule, String> classpathEntriesForDeps = Classpaths
                            .getClasspathEntries(getDeps());

                    ImmutableSetMultimap<JavaLibraryRule, String> classpathEntriesForExportedsDeps = Classpaths
                            .getClasspathEntries(getExportedDeps());

                    classpathEntries.putAll(classpathEntriesForDeps);

                    // If we have any exported deps, add an entry mapping ourselves to to their classpaths,
                    // so when suggesting libraries to add we know that adding this library would pull in
                    // it's deps.
                    if (!classpathEntriesForExportedsDeps.isEmpty()) {
                        classpathEntries.putAll(DefaultJavaLibraryRule.this,
                                classpathEntriesForExportedsDeps.values());
                    }

                    // Only add ourselves to the classpath if there's a jar to be built.
                    if (outputJar.isPresent()) {
                        classpathEntries.putAll(DefaultJavaLibraryRule.this, getPathToOutputFile());
                    }

                    return classpathEntries.build();
                }
            });

    declaredClasspathEntriesSupplier = Suppliers
            .memoize(new Supplier<ImmutableSetMultimap<JavaLibraryRule, String>>() {
                @Override
                public ImmutableSetMultimap<JavaLibraryRule, String> get() {
                    final ImmutableSetMultimap.Builder<JavaLibraryRule, String> classpathEntries = ImmutableSetMultimap
                            .builder();

                    Iterable<JavaLibraryRule> javaLibraryDeps = Iterables.filter(getDeps(),
                            JavaLibraryRule.class);

                    for (JavaLibraryRule rule : javaLibraryDeps) {
                        classpathEntries.putAll(rule, rule.getOutputClasspathEntries().values());
                    }
                    return classpathEntries.build();
                }
            });
}

From source file:com.google.caliper.runner.options.ParsedOptions.java

@Override
public ImmutableSetMultimap<String, String> userParameters() {
    // de-dup values, but keep in order
    return new ImmutableSetMultimap.Builder<String, String>().orderKeysBy(Ordering.natural())
            .putAll(mutableUserParameters).build();
}

From source file:org.sonar.server.computation.task.projectanalysis.measure.MeasureRepositoryRule.java

@Override
public SetMultimap<String, Measure> getRawMeasures(Component component) {
    ImmutableSetMultimap.Builder<String, Measure> builder = ImmutableSetMultimap.builder();
    for (Map.Entry<InternalKey, Measure> entry : filterKeys(rawMeasures, hasComponentRef(component))
            .entrySet()) {/* ww w . j  a  v a2s . c  o m*/
        builder.put(entry.getKey().getMetricKey(), entry.getValue());
    }
    return builder.build();
}

From source file:org.tensorics.core.tensor.Positions.java

/**
 * Combines all position pairs into positions containing the given dimensions and returns a map from the combined
 * positions to the original position pairs.
 *
 * @param positionPairs the position pairs to combine the final positions
 * @param targetDimensions the dimensions in which to combine the positions
 * @return a map from the combined dimensions to the original pairs
 *//* w  w w  .j  a  va 2s .co  m*/
public static ImmutableSetMultimap<Position, PositionPair> combineAll(Set<PositionPair> positionPairs,
        Set<Class<?>> targetDimensions) {
    ImmutableSetMultimap.Builder<Position, PositionPair> builder = ImmutableSetMultimap.builder();
    for (PositionPair pair : positionPairs) {
        builder.put(combineDimensions(pair, targetDimensions), pair);
    }
    return builder.build();
}

From source file:com.facebook.buck.features.apple.project.WorkspaceAndProjectGenerator.java

public Path generateWorkspaceAndDependentProjects(Map<Path, ProjectGenerator> projectGenerators,
        ListeningExecutorService listeningExecutorService) throws IOException, InterruptedException {
    LOG.debug("Generating workspace for target %s", workspaceBuildTarget);

    String workspaceName = XcodeWorkspaceConfigDescription.getWorkspaceNameFromArg(workspaceArguments);
    Path outputDirectory;//from   w  w w.  java2  s  .  com
    if (combinedProject) {
        workspaceName += "-Combined";
        outputDirectory = BuildTargetPaths.getGenPath(rootCell.getFilesystem(), workspaceBuildTarget, "%s")
                .getParent().resolve(workspaceName + ".xcodeproj");
    } else {
        outputDirectory = workspaceBuildTarget.getBasePath();
    }

    WorkspaceGenerator workspaceGenerator = new WorkspaceGenerator(rootCell.getFilesystem(),
            combinedProject ? "project" : workspaceName, outputDirectory);

    ImmutableMap.Builder<String, XcodeWorkspaceConfigDescriptionArg> schemeConfigsBuilder = ImmutableMap
            .builder();
    ImmutableSetMultimap.Builder<String, Optional<TargetNode<?>>> schemeNameToSrcTargetNodeBuilder = ImmutableSetMultimap
            .builder();
    ImmutableSetMultimap.Builder<String, TargetNode<?>> buildForTestNodesBuilder = ImmutableSetMultimap
            .builder();
    ImmutableSetMultimap.Builder<String, TargetNode<AppleTestDescriptionArg>> testsBuilder = ImmutableSetMultimap
            .builder();

    buildWorkspaceSchemes(projectGraph, projectGeneratorOptions.shouldIncludeTests(),
            projectGeneratorOptions.shouldIncludeDependenciesTests(), workspaceName, workspaceArguments,
            schemeConfigsBuilder, schemeNameToSrcTargetNodeBuilder, buildForTestNodesBuilder, testsBuilder);

    ImmutableMap<String, XcodeWorkspaceConfigDescriptionArg> schemeConfigs = schemeConfigsBuilder.build();
    ImmutableSetMultimap<String, Optional<TargetNode<?>>> schemeNameToSrcTargetNode = schemeNameToSrcTargetNodeBuilder
            .build();
    ImmutableSetMultimap<String, TargetNode<?>> buildForTestNodes = buildForTestNodesBuilder.build();
    ImmutableSetMultimap<String, TargetNode<AppleTestDescriptionArg>> tests = testsBuilder.build();

    ImmutableSet<BuildTarget> targetsInRequiredProjects = Stream
            .concat(schemeNameToSrcTargetNode.values().stream().flatMap(Optionals::toStream),
                    buildForTestNodes.values().stream())
            .map(TargetNode::getBuildTarget).collect(ImmutableSet.toImmutableSet());
    ImmutableMap.Builder<BuildTarget, PBXTarget> buildTargetToPbxTargetMapBuilder = ImmutableMap.builder();
    ImmutableSetMultimap.Builder<PBXProject, PBXTarget> generatedProjectToPbxTargetsBuilder = ImmutableSetMultimap
            .builder();
    ImmutableMap.Builder<PBXTarget, Path> targetToProjectPathMapBuilder = ImmutableMap.builder();
    generateProjects(projectGenerators, listeningExecutorService, workspaceName, outputDirectory,
            workspaceGenerator, targetsInRequiredProjects, generatedProjectToPbxTargetsBuilder,
            buildTargetToPbxTargetMapBuilder, targetToProjectPathMapBuilder);

    writeWorkspaceMetaData(outputDirectory, workspaceName);

    if (projectGeneratorOptions.shouldGenerateHeaderSymlinkTreesOnly()) {
        return workspaceGenerator.getWorkspaceDir();
    } else {
        ImmutableMap<BuildTarget, PBXTarget> buildTargetToPBXTarget = buildTargetToPbxTargetMapBuilder.build();
        ImmutableMap<PBXTarget, Path> targetToProjectPathMap = targetToProjectPathMapBuilder.build();
        ImmutableSetMultimap<PBXProject, PBXTarget> generatedProjectToPbxTargets = generatedProjectToPbxTargetsBuilder
                .build();

        ImmutableSetMultimap<String, PBXTarget> schemeBuildForTestNodeTargets = WorkspaceAndProjectGenerator
                .mapFromSchemeToPBXProject(buildForTestNodes, buildTargetToPBXTarget);
        ImmutableSetMultimap<String, PBXTarget> schemeUngroupedTestTargets = WorkspaceAndProjectGenerator
                .mapFromSchemeToPBXProject(tests, buildTargetToPBXTarget);

        if (projectGeneratorOptions.shouldGenerateProjectSchemes()) {
            // compose the project targets of targets that are within the main (or extra) scheme's
            // targets
            ImmutableSet<PBXTarget> schemeTargets = ImmutableSet
                    .copyOf(mapFromOptionalSchemeToPBXProject(schemeNameToSrcTargetNode, buildTargetToPBXTarget)
                            .values());

            LOG.debug("Generating schemes for all sub-projects.");

            writeWorkspaceSchemesForProjects(workspaceName, outputDirectory, schemeTargets,
                    generatedProjectToPbxTargets, targetToProjectPathMap, schemeBuildForTestNodeTargets,
                    schemeUngroupedTestTargets);
        }

        writeWorkspaceSchemes(workspaceName, outputDirectory, schemeConfigs, schemeNameToSrcTargetNode,
                schemeBuildForTestNodeTargets, schemeUngroupedTestTargets, targetToProjectPathMap,
                buildTargetToPBXTarget);

        return workspaceGenerator.writeWorkspace();
    }
}