Example usage for com.google.common.collect ImmutableMultimap.Builder put

List of usage examples for com.google.common.collect ImmutableMultimap.Builder put

Introduction

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

Prototype

@Deprecated
@Override
public boolean put(K key, V value) 

Source Link

Document

Guaranteed to throw an exception and leave the multimap unmodified.

Usage

From source file:org.lanternpowered.server.asset.FileAssetRepository.java

@Override
public Multimap<String, Asset> getAssetsMap(String path, boolean checkChildDirectories) {
    final ImmutableMultimap.Builder<String, Asset> builder = ImmutableMultimap.builder();
    final Enumeration<? extends ZipEntry> enumeration = getZipFile().entries();
    final Pattern pattern = Pattern.compile(generateRegex(path));
    while (enumeration.hasMoreElements()) {
        final ZipEntry zipEntry = enumeration.nextElement();
        final String name = zipEntry.getName().replace('\\', '/');
        final Matcher matcher = pattern.matcher(name);
        if (matcher.matches()) {
            final String id = matcher.group(2).toLowerCase(Locale.ENGLISH);
            final int index = id.indexOf('/');
            if (index == -1 || (checkChildDirectories && index != id.lastIndexOf('/'))) {
                continue;
            }//  ww  w.j  a  va  2s.c  o  m
            final String plugin = matcher.group(1).toLowerCase(Locale.ENGLISH);
            builder.put(id.substring(0, index),
                    registerAsset(plugin, plugin + ':' + id, generateAssetURL(name), Paths.get(name)));
        }
    }
    return builder.build();
}

From source file:edu.udo.scaffoldhunter.model.dataimport.ImportProcess.java

private ImmutableMultimap<ImportJob, Integer> getPropertiesWithUndefinedMergeStrategy() {
    ImmutableMultimap.Builder<ImportJob, Integer> builder = ImmutableMultimap.builder();
    Set<PropertyDefinition> propertyDefinitions = Sets.newHashSet();
    for (ImportJob s : importJobs) {
        int i = -1;
        for (SourcePropertyMapping m : s.getPropertyMappings().values()) {
            i++;//from  w  w w .ja v a 2  s  .c om
            PropertyDefinition propDef = m.getPropertyDefiniton();
            if (propDef == null)
                continue;
            if (propertyDefinitions.contains(propDef) && m.getMergeStrategy() == MergeStrategy.NONE)
                builder.put(s, i);
            else
                propertyDefinitions.add(propDef);
        }

    }
    return builder.build();
}

From source file:com.facebook.presto.raptor.storage.BucketBalancer.java

@VisibleForTesting
ClusterState fetchClusterState() {//w w  w .ja  va2s . co  m
    Set<String> activeNodes = nodeSupplier.getWorkerNodes().stream().map(Node::getNodeIdentifier)
            .collect(toSet());

    Map<String, Long> assignedNodeSize = new HashMap<>(
            activeNodes.stream().collect(toMap(node -> node, node -> 0L)));
    ImmutableMultimap.Builder<Distribution, BucketAssignment> distributionAssignments = ImmutableMultimap
            .builder();
    ImmutableMap.Builder<Distribution, Long> distributionBucketSize = ImmutableMap.builder();

    for (Distribution distribution : shardManager.getDistributions()) {
        long distributionSize = shardManager.getDistributionSizeInBytes(distribution.getId());
        long bucketSize = (long) (1.0 * distributionSize) / distribution.getBucketCount();
        distributionBucketSize.put(distribution, bucketSize);

        for (BucketNode bucketNode : shardManager.getBucketNodes(distribution.getId())) {
            String node = bucketNode.getNodeIdentifier();
            distributionAssignments.put(distribution,
                    new BucketAssignment(distribution.getId(), bucketNode.getBucketNumber(), node));
            assignedNodeSize.merge(node, bucketSize, Math::addExact);
        }
    }

    return new ClusterState(activeNodes, assignedNodeSize, distributionAssignments.build(),
            distributionBucketSize.build());
}

From source file:org.apache.awf.web.http.HttpRequestImpl.java

private ImmutableMultimap<String, String> parseParameters(String params) {
    ImmutableMultimap.Builder<String, String> builder = ImmutableMultimap.builder();

    String[] paramArray = PARAM_STRING_PATTERN.split(params);
    for (String keyValue : paramArray) {
        String[] keyValueArray = KEY_VALUE_PATTERN.split(keyValue);
        // We need to check if the parameter has a value associated with
        // it./* w w  w  .jav a  2s  .c  o m*/
        if (keyValueArray.length > 1) {
            String value = keyValueArray[1];
            try {
                value = URLDecoder.decode(value, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                // Should not happen
            }
            builder.put(keyValueArray[0], value);
        }
    }

    return builder.build();
}

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;/*from  w  w  w. j  ava  2  s.  co m*/
    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:it.cnr.istc.stlab.lizard.core.OntologyProjectGenerationRecipe.java

public void generateSwaggerDescription(String swaggerFolder) {

    LizardConfiguration l = LizardConfiguration.getInstance();

    ImmutableMultimap.Builder<String, AbstractOntologyCodeClass> builderMap = new ImmutableMultimap.Builder<>();

    AbstractOntologyCodeClass thingClass = this.ontologyModel.getOntologyClass(
            this.ontologyModel.asOntModel().getOntClass(OWL2.Thing.getURI()), BeanOntologyCodeInterface.class);

    this.ontologyModel.getEntityMap().get(BeanOntologyCodeClass.class).values().forEach(occ -> {
        builderMap.put(occ.getPackageName(), occ);
        builderMap.put(occ.getPackageName(), thingClass);
    });//from w w  w.  j  a v  a 2s  . com

    Multimap<String, AbstractOntologyCodeClass> map = builderMap.build();

    map.keySet().forEach(pack -> {
        String ontologyBasePath = "/" + pack.replaceAll("\\.", "_");
        new File(swaggerFolder + ontologyBasePath).mkdirs();
        DescriptionGenerator dg = new DescriptionGenerator();
        dg.setApiDescription("Rest services for accessing the api defined in the package " + pack
                + " for accessing the corresponding ontology.");
        dg.setApiTitle(pack);
        dg.setApiVersion(l.getApiVersion());
        dg.setBasePath(ontologyBasePath);
        dg.setContactName(l.getContactName());
        dg.setContanctEmail(l.getContanctEmail());
        dg.setHost(l.getHost());
        dg.setLicenseName(l.getLicenseName());
        dg.setLicenseUrl(l.getLicenseUrl());
        dg.setClasses(map.get(pack));
        try {
            FileOutputStream fos = new FileOutputStream(
                    new File(swaggerFolder + ontologyBasePath + "/swagger.json"));
            fos.write(dg.generateSwaggerJSONStringDescription().getBytes());
            fos.flush();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    });

}

From source file:org.tensorics.core.tensor.operations.InnerTensorOperation.java

@Override
public Tensor<V> perform(Tensor<V> left, Tensor<V> right) {
    checkNotNull(left, "left tensor must not be null!");
    checkNotNull(right, "right tensor must not be null!");

    List<CoContraDimensionPair> allPairs = CoContraDimensionPairs.coContraPairsOf(left.shape(), right.shape());
    List<CoContraDimensionPair> pairsToReduce = CoContraDimensionPairs.chooseOnePerContravariantPart(allPairs);
    Set<Class<?>> dimensionsNotToBroadcast = CoContraDimensionPairs.allDimensionsIn(pairsToReduce);

    TensorPair<V> broadcasted = broadcast(left, right, dimensionsNotToBroadcast);

    Set<Class<?>> leftDimensionsToReduce = CoContraDimensionPairs.leftDimensionsIn(pairsToReduce);
    Set<Class<?>> rightDimensionsToReduce = CoContraDimensionPairs.rightDimensionsIn(pairsToReduce);

    Set<Class<?>> remainingLeftDimensions = Sets
            .difference(broadcasted.left().shape().dimensionSet(), leftDimensionsToReduce).immutableCopy();
    Set<Class<?>> remainingRightDimensions = Sets
            .difference(broadcasted.right().shape().dimensionSet(), rightDimensionsToReduce).immutableCopy();

    Set<Class<?>> targetDimensions = Sets.union(remainingLeftDimensions, remainingRightDimensions)
            .immutableCopy();/*from  www.j  a va 2  s . c om*/
    Set<Class<?>> remainingCommonDimensions = Sets.intersection(remainingLeftDimensions,
            remainingRightDimensions);

    /*
     * produce a multimap from positions, consisting of all but the unique right dimensions to positions.
     */
    Set<Class<?>> uniqueLeftDimensions = Sets.difference(remainingLeftDimensions, remainingCommonDimensions);
    Set<Class<?>> uniqueRightDimensions = Sets.difference(remainingRightDimensions, remainingCommonDimensions);
    Multimap<Position, Position> nonUniqueToRightPositions = Positions
            .mapByStripping(broadcasted.right().shape().positionSet(), uniqueRightDimensions);

    DimensionStripper stripper = Positions.stripping(uniqueLeftDimensions);

    DimensionStripper targetLeftStripper = Positions.stripping(leftDimensionsToReduce);
    DimensionStripper targetRightStripper = Positions.stripping(rightDimensionsToReduce);

    ImmutableMultimap.Builder<Position, PositionPair> builder = ImmutableMultimap.builder();
    for (Position leftPosition : broadcasted.left().shape().positionSet()) {
        Position remainingLeftPosition = targetLeftStripper.apply(leftPosition);

        Position nonUniqueLeftPosition = stripper.apply(leftPosition);
        Position nonUniqueRightPosition = CoContraDimensionPairs.convertToRight(nonUniqueLeftPosition,
                pairsToReduce);
        Collection<Position> rightPositions = nonUniqueToRightPositions.get(nonUniqueRightPosition);
        for (Position rightPosition : rightPositions) {
            Position remainingRightPosition = targetRightStripper.apply(rightPosition);
            Position targetPosition = Positions.combineDimensions(remainingLeftPosition, remainingRightPosition,
                    targetDimensions);
            builder.put(targetPosition, PositionPair.fromLeftRight(leftPosition, rightPosition));
        }
    }

    Multimap<Position, PositionPair> targetPositionToPairs = builder.build();

    ListMultimap<Position, ValuePair<V>> valuePairs = broadcasted.mapValues(targetPositionToPairs);

    ListMultimap<Position, V> targetPositionToValueSet = Operations.mapAll(valuePairs, elementOperation);

    Map<Position, V> result = IterableOperations.reduce(targetPositionToValueSet, reductionOperation);

    ContextPropagationStrategy cps = optionRegistry.get(ContextPropagationStrategy.class);
    Position resultingContext = cps.contextForLeftRight(left.context(), right.context());

    TensorBuilder<V> finalBuilder = Tensorics.builder(targetDimensions);
    finalBuilder.putAll(result);
    finalBuilder.context(resultingContext);
    return finalBuilder.build();
}

From source file:com.continuuity.weave.internal.appmaster.ApplicationMasterService.java

private Queue<RunnableContainerRequest> initContainerRequests() {
    // Orderly stores container requests.
    Queue<RunnableContainerRequest> requests = Lists.newLinkedList();
    // For each order in the weaveSpec, create container request for each runnable.
    for (WeaveSpecification.Order order : weaveSpec.getOrders()) {
        // Group container requests based on resource requirement.
        ImmutableMultimap.Builder<Resource, RuntimeSpecification> builder = ImmutableMultimap.builder();
        for (String runnableName : order.getNames()) {
            RuntimeSpecification runtimeSpec = weaveSpec.getRunnables().get(runnableName);
            Resource capability = createCapability(runtimeSpec.getResourceSpecification());
            builder.put(capability, runtimeSpec);
        }//from   w  w  w.  j  av  a2  s . c  o m
        requests.add(new RunnableContainerRequest(order.getType(), builder.build()));
    }
    return requests;
}

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

private void generateProject(Map<Path, ProjectGenerator> projectGenerators,
        ListeningExecutorService listeningExecutorService, WorkspaceGenerator workspaceGenerator,
        ImmutableSet<BuildTarget> targetsInRequiredProjects,
        ImmutableSetMultimap.Builder<PBXProject, PBXTarget> generatedProjectToPbxTargetsBuilder,
        ImmutableMap.Builder<BuildTarget, PBXTarget> buildTargetToPbxTargetMapBuilder,
        ImmutableMap.Builder<PBXTarget, Path> targetToProjectPathMapBuilder)
        throws IOException, InterruptedException {
    ImmutableMultimap.Builder<Cell, BuildTarget> projectCellToBuildTargetsBuilder = ImmutableMultimap.builder();
    for (TargetNode<?> targetNode : projectGraph.getNodes()) {
        BuildTarget buildTarget = targetNode.getBuildTarget();
        projectCellToBuildTargetsBuilder.put(rootCell.getCell(buildTarget), buildTarget);
    }//  w w w . jav  a  2 s  . c  o  m
    ImmutableMultimap<Cell, BuildTarget> projectCellToBuildTargets = projectCellToBuildTargetsBuilder.build();
    List<ListenableFuture<GenerationResult>> projectGeneratorFutures = new ArrayList<>();
    for (Cell projectCell : projectCellToBuildTargets.keySet()) {
        ImmutableMultimap.Builder<Path, BuildTarget> projectDirectoryToBuildTargetsBuilder = ImmutableMultimap
                .builder();
        ImmutableSet<BuildTarget> cellRules = ImmutableSet.copyOf(projectCellToBuildTargets.get(projectCell));
        for (BuildTarget buildTarget : cellRules) {
            projectDirectoryToBuildTargetsBuilder.put(buildTarget.getBasePath(), buildTarget);
        }
        ImmutableMultimap<Path, BuildTarget> projectDirectoryToBuildTargets = projectDirectoryToBuildTargetsBuilder
                .build();
        Path relativeTargetCell = rootCell.getRoot().relativize(projectCell.getRoot());
        for (Path projectDirectory : projectDirectoryToBuildTargets.keySet()) {
            ImmutableSet<BuildTarget> rules = filterRulesForProjectDirectory(projectGraph,
                    ImmutableSet.copyOf(projectDirectoryToBuildTargets.get(projectDirectory)));
            if (Sets.intersection(targetsInRequiredProjects, rules).isEmpty()) {
                continue;
            }

            boolean isMainProject = workspaceArguments.getSrcTarget().isPresent()
                    && rules.contains(workspaceArguments.getSrcTarget().get());
            projectGeneratorFutures.add(listeningExecutorService.submit(() -> {
                GenerationResult result = generateProjectForDirectory(projectGenerators, projectCell,
                        projectDirectory, rules, isMainProject, targetsInRequiredProjects);
                // convert the projectPath to relative to the target cell here
                result = GenerationResult.of(relativeTargetCell.resolve(result.getProjectPath()),
                        result.isProjectGenerated(), result.getRequiredBuildTargets(),
                        result.getXcconfigPaths(), result.getFilesToCopyInXcode(),
                        result.getBuildTargetToGeneratedTargetMap(), result.getGeneratedProjectToPbxTargets());
                return result;
            }));
        }
    }

    List<GenerationResult> generationResults;
    try {
        generationResults = Futures.allAsList(projectGeneratorFutures).get();
    } catch (ExecutionException e) {
        Throwables.throwIfInstanceOf(e.getCause(), IOException.class);
        Throwables.throwIfUnchecked(e.getCause());
        throw new IllegalStateException("Unexpected exception: ", e);
    }
    for (GenerationResult result : generationResults) {
        if (!result.isProjectGenerated()) {
            continue;
        }
        workspaceGenerator.addFilePath(result.getProjectPath());
        processGenerationResult(generatedProjectToPbxTargetsBuilder, buildTargetToPbxTargetMapBuilder,
                targetToProjectPathMapBuilder, result);
    }
}

From source file:grakn.core.graql.reasoner.atom.binary.RelationAtom.java

/**
 * @return map of pairs role type - Id predicate describing the role player playing this role (substitution)
 *///  ww  w.  java  2s .  co  m
@Memoized
public Multimap<Role, String> getRoleConceptIdMap() {
    ImmutableMultimap.Builder<Role, String> builder = ImmutableMultimap.builder();
    getRolePredicateMap(IdPredicate.class).entries()
            .forEach(e -> builder.put(e.getKey(), e.getValue().getPredicateValue()));
    return builder.build();
}