List of usage examples for com.google.common.collect ImmutableMap values
public ImmutableCollection<V> values()
From source file:com.facebook.buck.lua.CxxLuaExtensionDescription.java
private ImmutableList<com.facebook.buck.rules.args.Arg> getExtensionArgs(BuildRuleParams params, BuildRuleResolver ruleResolver, SourcePathResolver pathResolver, SourcePathRuleFinder ruleFinder, CxxPlatform cxxPlatform, Arg args) throws NoSuchBuildTargetException { // Extract all C/C++ sources from the constructor arg. ImmutableMap<String, CxxSource> srcs = CxxDescriptionEnhancer.parseCxxSources(params.getBuildTarget(), pathResolver, cxxPlatform, args); ImmutableMap<Path, SourcePath> headers = CxxDescriptionEnhancer.parseHeaders(params.getBuildTarget(), pathResolver, Optional.of(cxxPlatform), args); // Setup the header symlink tree and combine all the preprocessor input from this rule // and all dependencies. HeaderSymlinkTree headerSymlinkTree = CxxDescriptionEnhancer.requireHeaderSymlinkTree(params, ruleResolver, pathResolver, cxxPlatform, headers, HeaderVisibility.PRIVATE, true); Optional<SymlinkTree> sandboxTree = Optional.empty(); if (cxxBuckConfig.sandboxSources()) { sandboxTree = CxxDescriptionEnhancer.createSandboxTree(params, ruleResolver, cxxPlatform); }/*from www .j a va 2 s . com*/ ImmutableList<CxxPreprocessorInput> cxxPreprocessorInput = CxxDescriptionEnhancer .collectCxxPreprocessorInput(params, cxxPlatform, CxxFlags.getLanguageFlags(args.preprocessorFlags, args.platformPreprocessorFlags, args.langPreprocessorFlags, cxxPlatform), ImmutableList.of(headerSymlinkTree), ImmutableSet.of(), CxxPreprocessables.getTransitiveCxxPreprocessorInput(cxxPlatform, params.getDeps()), args.includeDirs, sandboxTree); // Generate rule to build the object files. ImmutableMap<CxxPreprocessAndCompile, SourcePath> picObjects = CxxSourceRuleFactory .requirePreprocessAndCompileRules(params, ruleResolver, pathResolver, ruleFinder, cxxBuckConfig, cxxPlatform, cxxPreprocessorInput, CxxFlags.getLanguageFlags(args.compilerFlags, args.platformCompilerFlags, args.langCompilerFlags, cxxPlatform), args.prefixHeader, args.precompiledHeader, srcs, CxxSourceRuleFactory.PicType.PIC, sandboxTree); ImmutableList.Builder<com.facebook.buck.rules.args.Arg> argsBuilder = ImmutableList.builder(); argsBuilder .addAll(StringArg.from(CxxFlags.getFlags(args.linkerFlags, args.platformLinkerFlags, cxxPlatform))); // Add object files into the args. argsBuilder.addAll(SourcePathArg.from(pathResolver, picObjects.values())); return argsBuilder.build(); }
From source file:dagger.internal.codegen.BindingGraphFactory.java
private BindingGraph create(Optional<Resolver> parentResolver, ComponentDescriptor componentDescriptor) { ImmutableSet.Builder<ContributionBinding> explicitBindingsBuilder = ImmutableSet.builder(); ImmutableSet.Builder<DelegateDeclaration> delegatesBuilder = ImmutableSet.builder(); ImmutableSet.Builder<OptionalBindingDeclaration> optionalsBuilder = ImmutableSet.builder(); if (!componentDescriptor.kind().isForModuleValidation()) { // binding for the component itself explicitBindingsBuilder.add(bindingFactory.componentBinding(componentDescriptor.typeElement())); }/*www .j a v a 2s. c o m*/ // Collect Component dependencies. for (ComponentRequirement dependency : componentDescriptor.dependencies()) { explicitBindingsBuilder.add(bindingFactory.componentDependencyBinding(dependency)); List<ExecutableElement> dependencyMethods = methodsIn(elements.getAllMembers(dependency.typeElement())); for (ExecutableElement method : dependencyMethods) { // MembersInjection methods aren't "provided" explicitly, so ignore them. if (isComponentContributionMethod(elements, method)) { explicitBindingsBuilder .add(bindingFactory.componentDependencyMethodBinding(componentDescriptor, method)); } } } // Collect bindings on the creator. componentDescriptor.creatorDescriptor() .ifPresent(creatorDescriptor -> creatorDescriptor.boundInstanceRequirements().stream() .map(requirement -> bindingFactory.boundInstanceBinding(requirement, creatorDescriptor.elementForRequirement(requirement))) .forEach(explicitBindingsBuilder::add)); componentDescriptor.childComponentsDeclaredByBuilderEntryPoints() .forEach((builderEntryPoint, childComponent) -> { if (!componentDescriptor.childComponentsDeclaredByModules().contains(childComponent)) { explicitBindingsBuilder.add(bindingFactory.subcomponentCreatorBinding( builderEntryPoint.methodElement(), componentDescriptor.typeElement())); } }); ImmutableSet.Builder<MultibindingDeclaration> multibindingDeclarations = ImmutableSet.builder(); ImmutableSet.Builder<SubcomponentDeclaration> subcomponentDeclarations = ImmutableSet.builder(); // Collect transitive module bindings and multibinding declarations. for (ModuleDescriptor moduleDescriptor : modules(componentDescriptor, parentResolver)) { explicitBindingsBuilder.addAll(moduleDescriptor.bindings()); multibindingDeclarations.addAll(moduleDescriptor.multibindingDeclarations()); subcomponentDeclarations.addAll(moduleDescriptor.subcomponentDeclarations()); delegatesBuilder.addAll(moduleDescriptor.delegateDeclarations()); optionalsBuilder.addAll(moduleDescriptor.optionalDeclarations()); } final Resolver requestResolver = new Resolver(parentResolver, componentDescriptor, indexBindingDeclarationsByKey(explicitBindingsBuilder.build()), indexBindingDeclarationsByKey(multibindingDeclarations.build()), indexBindingDeclarationsByKey(subcomponentDeclarations.build()), indexBindingDeclarationsByKey(delegatesBuilder.build()), indexBindingDeclarationsByKey(optionalsBuilder.build())); for (DependencyRequest entryPoint : componentDescriptor.entryPoints()) { if (entryPoint.kind().equals(RequestKind.MEMBERS_INJECTION)) { requestResolver.resolveMembersInjection(entryPoint.key()); } else { requestResolver.resolve(entryPoint.key()); } } // Resolve all bindings for subcomponents, creating subgraphs for all subcomponents that have // been detected during binding resolution. If a binding for a subcomponent is never resolved, // no BindingGraph will be created for it and no implementation will be generated. This is // done in a queue since resolving one subcomponent might resolve a key for a subcomponent // from a parent graph. This is done until no more new subcomponents are resolved. Set<ComponentDescriptor> resolvedSubcomponents = new HashSet<>(); ImmutableList.Builder<BindingGraph> subgraphs = ImmutableList.builder(); for (ComponentDescriptor subcomponent : Iterables .consumingIterable(requestResolver.subcomponentsToResolve)) { if (resolvedSubcomponents.add(subcomponent)) { subgraphs.add(create(Optional.of(requestResolver), subcomponent)); } } ImmutableMap<Key, ResolvedBindings> resolvedContributionBindingsMap = requestResolver .getResolvedContributionBindings(); for (ResolvedBindings resolvedBindings : resolvedContributionBindingsMap.values()) { verify(resolvedBindings.owningComponent().equals(componentDescriptor), "%s is not owned by %s", resolvedBindings, componentDescriptor); } return BindingGraph.create(componentDescriptor, resolvedContributionBindingsMap, requestResolver.getResolvedMembersInjectionBindings(), subgraphs.build(), requestResolver.getOwnedModules(), requestResolver.getFactoryMethod()); }
From source file:com.google.devtools.build.lib.skyframe.PackageFunction.java
/** * Fetch the skylark loads for this BUILD file. If any of them haven't been computed yet, * returns null.//from w w w. ja va2 s. co m */ @Nullable static SkylarkImportResult fetchImportsFromBuildFile(Path buildFilePath, PackageIdentifier packageId, BuildFileAST buildFileAST, Environment env, SkylarkImportLookupFunction skylarkImportLookupFunctionForInlining) throws PackageFunctionException, InterruptedException { Preconditions.checkArgument(!packageId.getRepository().isDefault()); ImmutableList<SkylarkImport> imports = buildFileAST.getImports(); Map<String, Extension> importMap = Maps.newHashMapWithExpectedSize(imports.size()); ImmutableList.Builder<SkylarkFileDependency> fileDependencies = ImmutableList.builder(); ImmutableMap<String, Label> importPathMap; // Find the labels corresponding to the load statements. Label labelForCurrBuildFile; try { labelForCurrBuildFile = Label.create(packageId, "BUILD"); } catch (LabelSyntaxException e) { // Shouldn't happen; the Label is well-formed by construction. throw new IllegalStateException(e); } try { importPathMap = SkylarkImportLookupFunction.findLabelsForLoadStatements(imports, labelForCurrBuildFile, env); if (importPathMap == null) { return null; } } catch (SkylarkImportFailedException e) { throw new PackageFunctionException(new BuildFileContainsErrorsException(packageId, e.getMessage()), Transience.PERSISTENT); } // Look up and load the imports. ImmutableCollection<Label> importLabels = importPathMap.values(); List<SkyKey> importLookupKeys = Lists.newArrayListWithExpectedSize(importLabels.size()); boolean inWorkspace = buildFilePath.getBaseName().endsWith("WORKSPACE"); for (Label importLabel : importLabels) { importLookupKeys.add(SkylarkImportLookupValue.key(importLabel, inWorkspace)); } Map<SkyKey, SkyValue> skylarkImportMap = Maps.newHashMapWithExpectedSize(importPathMap.size()); boolean valuesMissing = false; try { if (skylarkImportLookupFunctionForInlining == null) { // Not inlining Map<SkyKey, ValueOrException2<SkylarkImportFailedException, InconsistentFilesystemException>> skylarkLookupResults = env .getValuesOrThrow(importLookupKeys, SkylarkImportFailedException.class, InconsistentFilesystemException.class); valuesMissing = env.valuesMissing(); for (Map.Entry<SkyKey, ValueOrException2<SkylarkImportFailedException, InconsistentFilesystemException>> entry : skylarkLookupResults .entrySet()) { // Fetching the value will raise any deferred exceptions skylarkImportMap.put(entry.getKey(), entry.getValue().get()); } } else { // Inlining calls to SkylarkImportLookupFunction LinkedHashMap<Label, SkylarkImportLookupValue> alreadyVisitedImports = Maps .newLinkedHashMapWithExpectedSize(importLookupKeys.size()); for (SkyKey importLookupKey : importLookupKeys) { SkyValue skyValue = skylarkImportLookupFunctionForInlining .computeWithInlineCalls(importLookupKey, env, alreadyVisitedImports); if (skyValue == null) { Preconditions.checkState(env.valuesMissing(), "no skylark import value for %s", importLookupKey); // We continue making inline calls even if some requested values are missing, to // maximize the number of dependent (non-inlined) SkyFunctions that are requested, thus // avoiding a quadratic number of restarts. valuesMissing = true; } else { skylarkImportMap.put(importLookupKey, skyValue); } } } } catch (SkylarkImportFailedException e) { throw new PackageFunctionException(new BuildFileContainsErrorsException(packageId, e.getMessage()), Transience.PERSISTENT); } catch (InconsistentFilesystemException e) { throw new PackageFunctionException(new NoSuchPackageException(packageId, e.getMessage(), e), Transience.PERSISTENT); } if (valuesMissing) { // Some imports are unavailable. return null; } // Process the loaded imports. for (Entry<String, Label> importEntry : importPathMap.entrySet()) { String importString = importEntry.getKey(); Label importLabel = importEntry.getValue(); SkyKey keyForLabel = SkylarkImportLookupValue.key(importLabel, inWorkspace); SkylarkImportLookupValue importLookupValue = (SkylarkImportLookupValue) skylarkImportMap .get(keyForLabel); importMap.put(importString, importLookupValue.getEnvironmentExtension()); fileDependencies.add(importLookupValue.getDependency()); } return new SkylarkImportResult(importMap, transitiveClosureOfLabels(fileDependencies.build())); }
From source file:com.facebook.buck.features.lua.CxxLuaExtensionDescription.java
private ImmutableList<Arg> getExtensionArgs(BuildTarget buildTarget, ProjectFilesystem projectFilesystem, ActionGraphBuilder graphBuilder, SourcePathResolver pathResolver, SourcePathRuleFinder ruleFinder, CellPathResolver cellRoots, LuaPlatform luaPlatform, CxxLuaExtensionDescriptionArg args) { CxxPlatform cxxPlatform = luaPlatform.getCxxPlatform(); // Extract all C/C++ sources from the constructor arg. ImmutableMap<String, CxxSource> srcs = CxxDescriptionEnhancer.parseCxxSources(buildTarget, graphBuilder, ruleFinder, pathResolver, cxxPlatform, args); ImmutableMap<Path, SourcePath> headers = CxxDescriptionEnhancer.parseHeaders(buildTarget, graphBuilder, ruleFinder, pathResolver, Optional.of(cxxPlatform), args); // Setup the header symlink tree and combine all the preprocessor input from this rule // and all dependencies. HeaderSymlinkTree headerSymlinkTree = CxxDescriptionEnhancer.requireHeaderSymlinkTree(buildTarget, projectFilesystem, ruleFinder, graphBuilder, cxxPlatform, headers, HeaderVisibility.PRIVATE, true); ImmutableSet<BuildRule> deps = args.getCxxDeps().get(graphBuilder, cxxPlatform); ImmutableList<CxxPreprocessorInput> cxxPreprocessorInput = ImmutableList.<CxxPreprocessorInput>builder() .add(luaPlatform.getLuaCxxLibrary(graphBuilder).getCxxPreprocessorInput(cxxPlatform, graphBuilder)) .addAll(CxxDescriptionEnhancer.collectCxxPreprocessorInput(buildTarget, cxxPlatform, graphBuilder, deps,/*from w w w .j a v a 2s. c o m*/ ImmutableListMultimap.copyOf(Multimaps.transformValues( CxxFlags.getLanguageFlagsWithMacros(args.getPreprocessorFlags(), args.getPlatformPreprocessorFlags(), args.getLangPreprocessorFlags(), args.getLangPlatformPreprocessorFlags(), cxxPlatform), f -> CxxDescriptionEnhancer.toStringWithMacrosArgs(buildTarget, cellRoots, graphBuilder, cxxPlatform, f))), ImmutableList.of(headerSymlinkTree), ImmutableSet.of(), CxxPreprocessables.getTransitiveCxxPreprocessorInput(cxxPlatform, graphBuilder, deps), args.getRawHeaders())) .build(); // Generate rule to build the object files. ImmutableMultimap<CxxSource.Type, Arg> compilerFlags = ImmutableListMultimap .copyOf(Multimaps.transformValues( CxxFlags.getLanguageFlagsWithMacros(args.getCompilerFlags(), args.getPlatformCompilerFlags(), args.getLangCompilerFlags(), args.getLangPlatformCompilerFlags(), cxxPlatform), f -> CxxDescriptionEnhancer.toStringWithMacrosArgs(buildTarget, cellRoots, graphBuilder, cxxPlatform, f))); ImmutableMap<CxxPreprocessAndCompile, SourcePath> picObjects = CxxSourceRuleFactory .of(projectFilesystem, buildTarget, graphBuilder, pathResolver, ruleFinder, cxxBuckConfig, cxxPlatform, cxxPreprocessorInput, compilerFlags, args.getPrefixHeader(), args.getPrecompiledHeader(), PicType.PIC) .requirePreprocessAndCompileRules(srcs); ImmutableList.Builder<Arg> argsBuilder = ImmutableList.builder(); CxxFlags.getFlagsWithMacrosWithPlatformMacroExpansion(args.getLinkerFlags(), args.getPlatformLinkerFlags(), cxxPlatform).stream() .map(f -> CxxDescriptionEnhancer.toStringWithMacrosArgs(buildTarget, cellRoots, graphBuilder, cxxPlatform, f)) .forEach(argsBuilder::add); // Add object files into the args. argsBuilder.addAll(SourcePathArg.from(picObjects.values())); return argsBuilder.build(); }
From source file:com.facebook.buck.cxx.CxxPythonExtensionDescription.java
private <A extends Arg> BuildRule createExtensionBuildRule(TargetGraph targetGraph, BuildRuleParams params, BuildRuleResolver ruleResolver, CxxPlatform cxxPlatform, A args) { SourcePathResolver pathResolver = new SourcePathResolver(ruleResolver); // Extract all C/C++ sources from the constructor arg. ImmutableMap<String, CxxSource> srcs = CxxDescriptionEnhancer.parseCxxSources(params, ruleResolver, cxxPlatform, args);//from w ww . j a va 2 s .c o m ImmutableMap<Path, SourcePath> headers = CxxDescriptionEnhancer.parseHeaders(params, ruleResolver, cxxPlatform, args); ImmutableMap<String, SourcePath> lexSrcs = CxxDescriptionEnhancer.parseLexSources(params, ruleResolver, args); ImmutableMap<String, SourcePath> yaccSrcs = CxxDescriptionEnhancer.parseYaccSources(params, ruleResolver, args); CxxHeaderSourceSpec lexYaccSources = CxxDescriptionEnhancer.createLexYaccBuildRules(params, ruleResolver, cxxPlatform, ImmutableList.<String>of(), lexSrcs, ImmutableList.<String>of(), yaccSrcs); // Setup the header symlink tree and combine all the preprocessor input from this rule // and all dependencies. HeaderSymlinkTree headerSymlinkTree = CxxDescriptionEnhancer.requireHeaderSymlinkTree(params, ruleResolver, new SourcePathResolver(ruleResolver), cxxPlatform, /* includeLexYaccHeaders */ true, lexSrcs, yaccSrcs, headers, HeaderVisibility.PRIVATE); ImmutableList<CxxPreprocessorInput> cxxPreprocessorInput = CxxDescriptionEnhancer .collectCxxPreprocessorInput(targetGraph, params, cxxPlatform, CxxFlags.getLanguageFlags(args.preprocessorFlags, args.platformPreprocessorFlags, args.langPreprocessorFlags, cxxPlatform), ImmutableList.of(headerSymlinkTree), ImmutableSet.<Path>of(), CxxPreprocessables .getTransitiveCxxPreprocessorInput(targetGraph, cxxPlatform, params.getDeps())); ImmutableMap<String, CxxSource> allSources = ImmutableMap.<String, CxxSource>builder().putAll(srcs) .putAll(lexYaccSources.getCxxSources()).build(); // Generate rule to build the object files. ImmutableMap<CxxPreprocessAndCompile, SourcePath> picObjects = CxxSourceRuleFactory .requirePreprocessAndCompileRules(params, ruleResolver, pathResolver, cxxPlatform, cxxPreprocessorInput, CxxFlags.getFlags(args.compilerFlags, args.platformCompilerFlags, cxxPlatform), args.prefixHeader, cxxBuckConfig.getPreprocessMode(), allSources, CxxSourceRuleFactory.PicType.PIC); // Setup the rules to link the shared library. String extensionName = getExtensionName(params.getBuildTarget()); Path extensionPath = getExtensionPath(params.getBuildTarget(), cxxPlatform.getFlavor()); return CxxLinkableEnhancer.createCxxLinkableBuildRule(targetGraph, cxxPlatform, params, pathResolver, /* extraLdFlags */ CxxFlags.getFlags(args.linkerFlags, args.platformLinkerFlags, cxxPlatform), getExtensionTarget(params.getBuildTarget(), cxxPlatform.getFlavor()), Linker.LinkType.SHARED, Optional.of(extensionName), extensionPath, picObjects.values(), /* extraInputs */ ImmutableList.<SourcePath>of(), Linker.LinkableDepType.SHARED, params.getDeps(), args.cxxRuntimeType, Optional.<SourcePath>absent(), ImmutableSet.<BuildRule>of()); }
From source file:com.facebook.buck.android.AndroidNativeLibsPackageableGraphEnhancer.java
public AndroidNativeLibsGraphEnhancementResult enhance(AndroidPackageableCollection packageableCollection) throws NoSuchBuildTargetException { @SuppressWarnings("PMD.PrematureDeclaration") AndroidNativeLibsGraphEnhancementResult.Builder resultBuilder = AndroidNativeLibsGraphEnhancementResult .builder();/* w ww .j a v a2 s. com*/ ImmutableMultimap<APKModule, NativeLinkable> nativeLinkables = packageableCollection.getNativeLinkables(); ImmutableMultimap<APKModule, NativeLinkable> nativeLinkablesAssets = packageableCollection .getNativeLinkablesAssets(); if (nativeLibraryMergeMap.isPresent() && !nativeLibraryMergeMap.get().isEmpty()) { NativeLibraryMergeEnhancementResult enhancement = NativeLibraryMergeEnhancer.enhance(cxxBuckConfig, ruleResolver, pathResolver, ruleFinder, buildRuleParams, nativePlatforms, nativeLibraryMergeMap.get(), nativeLibraryMergeGlue, nativeLinkables, nativeLinkablesAssets); nativeLinkables = enhancement.getMergedLinkables(); nativeLinkablesAssets = enhancement.getMergedLinkablesAssets(); resultBuilder.setSonameMergeMap(enhancement.getSonameMapping()); } // Iterate over all the {@link AndroidNativeLinkable}s from the collector and grab the shared // libraries for all the {@link TargetCpuType}s that we care about. We deposit them into a map // of CPU type and SONAME to the shared library path, which the {@link CopyNativeLibraries} // rule will use to compose the destination name. ImmutableMap.Builder<APKModule, CopyNativeLibraries> moduleMappedCopyNativeLibriesBuilder = ImmutableMap .builder(); boolean hasCopyNativeLibraries = false; List<NdkCxxPlatform> platformsWithNativeLibs = new ArrayList<>(); List<NdkCxxPlatform> platformsWithNativeLibsAssets = new ArrayList<>(); // Make sure we process the root module last so that we know if any of the module contain // libraries that depend on a non-system runtime and add it to the root module if needed. ImmutableSet<APKModule> apkModules = FluentIterable.from(apkModuleGraph.getAPKModules()) .filter(input -> !input.isRootModule()).append(apkModuleGraph.getRootAPKModule()).toSet(); for (APKModule module : apkModules) { ImmutableMap.Builder<Pair<NdkCxxPlatforms.TargetCpuType, String>, SourcePath> nativeLinkableLibsBuilder = ImmutableMap .builder(); ImmutableMap.Builder<Pair<NdkCxxPlatforms.TargetCpuType, String>, SourcePath> nativeLinkableLibsAssetsBuilder = ImmutableMap .builder(); // TODO(andrewjcg): We currently treat an empty set of filters to mean to allow everything. // We should fix this by assigning a default list of CPU filters in the descriptions, but // until we do, if the set of filters is empty, just build for all available platforms. ImmutableSet<NdkCxxPlatforms.TargetCpuType> filters = cpuFilters.isEmpty() ? nativePlatforms.keySet() : cpuFilters; for (NdkCxxPlatforms.TargetCpuType targetCpuType : filters) { NdkCxxPlatform platform = Preconditions.checkNotNull(nativePlatforms.get(targetCpuType), "Unknown platform type " + targetCpuType.toString()); // Populate nativeLinkableLibs and nativeLinkableLibsAssets with the appropriate entries. if (populateMapWithLinkables(nativeLinkables.get(module), nativeLinkableLibsBuilder, targetCpuType, platform) && !platformsWithNativeLibs.contains(platform)) { platformsWithNativeLibs.add(platform); } if (populateMapWithLinkables(nativeLinkablesAssets.get(module), nativeLinkableLibsAssetsBuilder, targetCpuType, platform) && !platformsWithNativeLibsAssets.contains(platform)) { platformsWithNativeLibsAssets.add(platform); } if (module.isRootModule()) { // If we're using a C/C++ runtime other than the system one, add it to the APK. NdkCxxPlatforms.CxxRuntime cxxRuntime = platform.getCxxRuntime(); if ((platformsWithNativeLibs.contains(platform) || platformsWithNativeLibsAssets.contains(platform)) && !cxxRuntime.equals(NdkCxxPlatforms.CxxRuntime.SYSTEM)) { nativeLinkableLibsBuilder.put(new Pair<>(targetCpuType, cxxRuntime.getSoname()), new PathSourcePath(buildRuleParams.getProjectFilesystem(), platform.getCxxSharedRuntimePath())); } } } ImmutableMap<Pair<NdkCxxPlatforms.TargetCpuType, String>, SourcePath> nativeLinkableLibs = nativeLinkableLibsBuilder .build(); ImmutableMap<Pair<NdkCxxPlatforms.TargetCpuType, String>, SourcePath> nativeLinkableLibsAssets = nativeLinkableLibsAssetsBuilder .build(); if (packageableCollection.getNativeLibsDirectories().get(module).isEmpty() && nativeLinkableLibs.isEmpty() && nativeLinkableLibsAssets.isEmpty()) { continue; } if (relinkerMode == RelinkerMode.ENABLED && (!nativeLinkableLibs.isEmpty() || !nativeLinkableLibsAssets.isEmpty())) { NativeRelinker relinker = new NativeRelinker( buildRuleParams .copyWithExtraDeps(Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder() .addAll(ruleFinder.filterBuildRuleInputs(nativeLinkableLibs.values())) .addAll(ruleFinder.filterBuildRuleInputs(nativeLinkableLibsAssets.values())) .build())), pathResolver, ruleFinder, cxxBuckConfig, nativePlatforms, nativeLinkableLibs, nativeLinkableLibsAssets); nativeLinkableLibs = relinker.getRelinkedLibs(); nativeLinkableLibsAssets = relinker.getRelinkedLibsAssets(); for (BuildRule rule : relinker.getRules()) { ruleResolver.addToIndex(rule); } } ImmutableMap<StripLinkable, StrippedObjectDescription> strippedLibsMap = generateStripRules( buildRuleParams, ruleFinder, ruleResolver, originalBuildTarget, nativePlatforms, nativeLinkableLibs); ImmutableMap<StripLinkable, StrippedObjectDescription> strippedLibsAssetsMap = generateStripRules( buildRuleParams, ruleFinder, ruleResolver, originalBuildTarget, nativePlatforms, nativeLinkableLibsAssets); BuildTarget targetForCopyNativeLibraries = BuildTarget.builder(originalBuildTarget) .addFlavors(ImmutableFlavor.of(COPY_NATIVE_LIBS + "_" + module.getName())).build(); ImmutableSortedSet<BuildRule> nativeLibsRules = BuildRules.toBuildRulesFor(originalBuildTarget, ruleResolver, packageableCollection.getNativeLibsTargets().get(module)); BuildRuleParams paramsForCopyNativeLibraries = buildRuleParams.copyWithChanges( targetForCopyNativeLibraries, Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder().addAll(nativeLibsRules) .addAll(ruleFinder.filterBuildRuleInputs( packageableCollection.getNativeLibsDirectories().get(module))) .addAll(strippedLibsMap.keySet()).addAll(strippedLibsAssetsMap.keySet()).build()), /* extraDeps */ Suppliers.ofInstance(ImmutableSortedSet.of())); moduleMappedCopyNativeLibriesBuilder.put(module, new CopyNativeLibraries(paramsForCopyNativeLibraries, ImmutableSet.copyOf(packageableCollection.getNativeLibsDirectories().get(module)), ImmutableSet.copyOf(strippedLibsMap.values()), ImmutableSet.copyOf(strippedLibsAssetsMap.values()), cpuFilters, module.getName())); hasCopyNativeLibraries = true; } return resultBuilder.setCopyNativeLibraries( hasCopyNativeLibraries ? Optional.of(moduleMappedCopyNativeLibriesBuilder.build()) : Optional.empty()) .build(); }
From source file:com.facebook.buck.android.NativeLibraryMergeEnhancer.java
@SuppressWarnings("PMD.PrematureDeclaration") static NativeLibraryMergeEnhancementResult enhance(CxxBuckConfig cxxBuckConfig, BuildRuleResolver ruleResolver, SourcePathResolver pathResolver, SourcePathRuleFinder ruleFinder, BuildRuleParams buildRuleParams, ImmutableMap<NdkCxxPlatforms.TargetCpuType, NdkCxxPlatform> nativePlatforms, Map<String, List<Pattern>> mergeMap, Optional<BuildTarget> nativeLibraryMergeGlue, ImmutableMultimap<APKModule, NativeLinkable> linkables, ImmutableMultimap<APKModule, NativeLinkable> linkablesAssets) throws NoSuchBuildTargetException { NativeLibraryMergeEnhancer.ruleFinder = ruleFinder; NativeLibraryMergeEnhancementResult.Builder builder = NativeLibraryMergeEnhancementResult.builder(); ImmutableSet<APKModule> modules = ImmutableSet.<APKModule>builder().addAll(linkables.keySet()) .addAll(linkablesAssets.keySet()).build(); ImmutableSortedMap.Builder<String, String> sonameMapBuilder = ImmutableSortedMap.naturalOrder(); for (APKModule module : modules) { // Sort by build target here to ensure consistent behavior. Iterable<NativeLinkable> allLinkables = FluentIterable .from(Iterables.concat(linkables.get(module), linkablesAssets.get(module))) .toSortedList(HasBuildTarget.BUILD_TARGET_COMPARATOR); final ImmutableSet<NativeLinkable> linkableAssetSet = ImmutableSet.copyOf(linkablesAssets.get(module)); Map<NativeLinkable, MergedNativeLibraryConstituents> linkableMembership = makeConstituentMap( buildRuleParams, mergeMap, allLinkables, linkableAssetSet); sonameMapBuilder.putAll(makeSonameMap( // sonames can *theoretically* differ per-platform, but right now they don't on Android, // so just pick the first platform and use that to get all the sonames. nativePlatforms.values().iterator().next().getCxxPlatform(), linkableMembership)); Iterable<MergedNativeLibraryConstituents> orderedConstituents = getOrderedMergedConstituents( buildRuleParams, linkableMembership); Optional<NativeLinkable> glueLinkable = Optional.empty(); if (nativeLibraryMergeGlue.isPresent()) { BuildRule rule = ruleResolver.getRule(nativeLibraryMergeGlue.get()); if (!(rule instanceof NativeLinkable)) { throw new RuntimeException("Native library merge glue " + rule.getBuildTarget() + " for application " + buildRuleParams.getBuildTarget() + " is not linkable."); }/* w ww. j av a 2 s. c om*/ glueLinkable = Optional.of(((NativeLinkable) rule)); } Set<MergedLibNativeLinkable> mergedLinkables = createLinkables(cxxBuckConfig, ruleResolver, pathResolver, buildRuleParams, glueLinkable, orderedConstituents); for (MergedLibNativeLinkable linkable : mergedLinkables) { if (Collections.disjoint(linkable.constituents.getLinkables(), linkableAssetSet)) { builder.putMergedLinkables(module, linkable); } else if (linkableAssetSet.containsAll(linkable.constituents.getLinkables())) { builder.putMergedLinkablesAssets(module, linkable); } } } builder.setSonameMapping(sonameMapBuilder.build()); return builder.build(); }
From source file:com.facebook.buck.python.CxxPythonExtensionDescription.java
private ImmutableList<com.facebook.buck.rules.args.Arg> getExtensionArgs(BuildRuleParams params, BuildRuleResolver ruleResolver, SourcePathResolver pathResolver, SourcePathRuleFinder ruleFinder, CxxPlatform cxxPlatform, Arg args) throws NoSuchBuildTargetException { // Extract all C/C++ sources from the constructor arg. ImmutableMap<String, CxxSource> srcs = CxxDescriptionEnhancer.parseCxxSources(params.getBuildTarget(), pathResolver, cxxPlatform, args); ImmutableMap<Path, SourcePath> headers = CxxDescriptionEnhancer.parseHeaders(params.getBuildTarget(), pathResolver, Optional.of(cxxPlatform), args); // Setup the header symlink tree and combine all the preprocessor input from this rule // and all dependencies. HeaderSymlinkTree headerSymlinkTree = CxxDescriptionEnhancer.requireHeaderSymlinkTree(params, ruleResolver, pathResolver, cxxPlatform, headers, HeaderVisibility.PRIVATE, true); Optional<SymlinkTree> sandboxTree = Optional.empty(); if (cxxBuckConfig.sandboxSources()) { sandboxTree = CxxDescriptionEnhancer.createSandboxTree(params, ruleResolver, cxxPlatform); }/*from w ww . j a v a2 s .c om*/ ImmutableList<CxxPreprocessorInput> cxxPreprocessorInput = CxxDescriptionEnhancer .collectCxxPreprocessorInput(params, cxxPlatform, CxxFlags.getLanguageFlags(args.preprocessorFlags, args.platformPreprocessorFlags, args.langPreprocessorFlags, cxxPlatform), ImmutableList.of(headerSymlinkTree), ImmutableSet.of(), CxxPreprocessables.getTransitiveCxxPreprocessorInput(cxxPlatform, params.getDeps()), args.includeDirs, sandboxTree); // Generate rule to build the object files. ImmutableMap<CxxPreprocessAndCompile, SourcePath> picObjects = CxxSourceRuleFactory .requirePreprocessAndCompileRules(params, ruleResolver, pathResolver, ruleFinder, cxxBuckConfig, cxxPlatform, cxxPreprocessorInput, CxxFlags.getLanguageFlags(args.compilerFlags, args.platformCompilerFlags, args.langCompilerFlags, cxxPlatform), args.prefixHeader, args.precompiledHeader, srcs, CxxSourceRuleFactory.PicType.PIC, sandboxTree); ImmutableList.Builder<com.facebook.buck.rules.args.Arg> argsBuilder = ImmutableList.builder(); argsBuilder .addAll(StringArg.from(CxxFlags.getFlags(args.linkerFlags, args.platformLinkerFlags, cxxPlatform))); // Embed a origin-relative library path into the binary so it can find the shared libraries. argsBuilder.addAll(StringArg.from(Linkers.iXlinker("-rpath", String.format("%s/", cxxPlatform.getLd().resolve(ruleResolver).libOrigin())))); // Add object files into the args. argsBuilder.addAll(SourcePathArg.from(pathResolver, picObjects.values())); return argsBuilder.build(); }
From source file:com.facebook.buck.cxx.CxxLibraryDescription.java
/** * Create all build rules needed to generate the shared library. * * @return the {@link CxxLink} rule representing the actual shared library. *///from w w w . j a va2s . c om private static BuildRule createSharedLibrary(BuildRuleParams params, BuildRuleResolver ruleResolver, SourcePathResolver pathResolver, SourcePathRuleFinder ruleFinder, CxxBuckConfig cxxBuckConfig, CxxPlatform cxxPlatform, CxxLibraryDescription.Arg args, ImmutableList<String> linkerFlags, ImmutableSet<FrameworkPath> frameworks, ImmutableSet<FrameworkPath> libraries, Optional<String> soname, Optional<Linker.CxxRuntimeType> cxxRuntimeType, Linker.LinkType linkType, Linker.LinkableDepType linkableDepType, Optional<SourcePath> bundleLoader, ImmutableSet<BuildTarget> blacklist) throws NoSuchBuildTargetException { Optional<LinkerMapMode> flavoredLinkerMapMode = LinkerMapMode.FLAVOR_DOMAIN .getValue(params.getBuildTarget()); params = LinkerMapMode.removeLinkerMapModeFlavorInParams(params, flavoredLinkerMapMode); // Create rules for compiling the PIC object files. ImmutableMap<CxxPreprocessAndCompile, SourcePath> objects = CxxDescriptionEnhancer.requireObjects(params, ruleResolver, pathResolver, ruleFinder, cxxBuckConfig, cxxPlatform, CxxSourceRuleFactory.PicType.PIC, args); // Setup the rules to link the shared library. BuildTarget sharedTarget = CxxDescriptionEnhancer.createSharedLibraryBuildTarget( LinkerMapMode.restoreLinkerMapModeFlavorInParams(params, flavoredLinkerMapMode).getBuildTarget(), cxxPlatform.getFlavor(), linkType); String sharedLibrarySoname = CxxDescriptionEnhancer.getSharedLibrarySoname(soname, params.getBuildTarget(), cxxPlatform); Path sharedLibraryPath = CxxDescriptionEnhancer.getSharedLibraryPath(params.getProjectFilesystem(), sharedTarget, sharedLibrarySoname); ImmutableList.Builder<String> extraLdFlagsBuilder = ImmutableList.builder(); extraLdFlagsBuilder.addAll(linkerFlags); ImmutableList<String> extraLdFlags = extraLdFlagsBuilder.build(); return CxxLinkableEnhancer.createCxxLinkableBuildRule(cxxBuckConfig, cxxPlatform, LinkerMapMode.restoreLinkerMapModeFlavorInParams(params, flavoredLinkerMapMode), ruleResolver, pathResolver, ruleFinder, sharedTarget, linkType, Optional.of(sharedLibrarySoname), sharedLibraryPath, linkableDepType, Iterables.filter(params.getDeps(), NativeLinkable.class), cxxRuntimeType, bundleLoader, blacklist, NativeLinkableInput.builder() .addAllArgs(FluentIterable.from(extraLdFlags) .transform(MacroArg.toMacroArgFunction(MACRO_HANDLER, params.getBuildTarget(), params.getCellRoots(), ruleResolver))) .addAllArgs(SourcePathArg.from(pathResolver, objects.values())).setFrameworks(frameworks) .setLibraries(libraries).build()); }
From source file:grakn.core.graql.gremlin.TraversalPlanner.java
/** * Create a plan using Edmonds' algorithm with greedy approach to execute a single conjunction * * @param query the conjunction query to find a traversal plan * @return a semi-optimal traversal plan to execute the given conjunction *//*from w w w . j ava 2 s. co m*/ private static List<Fragment> planForConjunction(ConjunctionQuery query, TransactionOLTP tx) { // a query plan is an ordered list of fragments final List<Fragment> plan = new ArrayList<>(); // flatten all the possible fragments from the conjunction query (these become edges in the query graph) final Set<Fragment> allFragments = query.getEquivalentFragmentSets().stream() .flatMap(EquivalentFragmentSet::stream).collect(Collectors.toSet()); // if role players' types are known, we can infer the types of the relation, adding label & isa fragments Set<Fragment> inferredFragments = inferRelationTypes(tx, allFragments); allFragments.addAll(inferredFragments); // convert fragments into nodes - some fragments create virtual middle nodes to ensure the Janus edge is traversed ImmutableMap<NodeId, Node> queryGraphNodes = buildNodesWithDependencies(allFragments); // it's possible that some (or all) fragments are disconnected, e.g. $x isa person; $y isa dog; Collection<Set<Fragment>> connectedFragmentSets = getConnectedFragmentSets(allFragments); // build a query plan for each query subgraph separately for (Set<Fragment> connectedFragments : connectedFragmentSets) { // one of two cases - either we have a connected graph > 1 node, which is used to compute a MST, OR exactly 1 node Arborescence<Node> subgraphArborescence = computeArborescence(connectedFragments, queryGraphNodes, tx); if (subgraphArborescence != null) { // collect the mapping from directed edge back to fragments -- inverse operation of creating virtual middle nodes Map<Node, Map<Node, Fragment>> middleNodeFragmentMapping = virtualMiddleNodeToFragmentMapping( connectedFragments, queryGraphNodes); List<Fragment> subplan = GreedyTreeTraversal.greedyTraversal(subgraphArborescence, queryGraphNodes, middleNodeFragmentMapping); plan.addAll(subplan); } else { // find and include all the nodes not touched in the MST in the plan Set<Node> unhandledNodes = connectedFragments.stream() .flatMap(fragment -> fragment.getNodes().stream()) .map(node -> queryGraphNodes.get(node.getNodeId())).collect(Collectors.toSet()); if (unhandledNodes.size() != 1) { throw GraknServerException .create("Query planner exception - expected one unhandled node, found " + unhandledNodes.size()); } plan.addAll(nodeVisitedDependenciesFragments(Iterators.getOnlyElement(unhandledNodes.iterator()), queryGraphNodes)); } } // this shouldn't be necessary, but we keep it just in case of an edge case that we haven't thought of List<Fragment> remainingFragments = fragmentsForUnvisitedNodes(queryGraphNodes, queryGraphNodes.values()); if (remainingFragments.size() > 0) { LOG.warn("Expected all fragments to be handled, but found these: " + remainingFragments); plan.addAll(remainingFragments); } LOG.trace("Greedy Plan = {}", plan); return plan; }