private ImmutableSet<String> prepareDirectory( String dirname, Pattern filePattern, ImmutableSet<String> requiredHashes) throws Exception { try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "prepare_" + dirname)) { String dirPath = dataRoot.resolve(dirname).toString(); mkDirP(dirPath); String output = AdbHelper.executeCommandWithErrorChecking(device, "ls " + dirPath); ImmutableSet.Builder<String> foundHashes = ImmutableSet.builder(); ImmutableSet.Builder<String> filesToDelete = ImmutableSet.builder(); processLsOutput(output, filePattern, requiredHashes, foundHashes, filesToDelete); String commandPrefix = "cd " + dirPath + " && rm "; // Add a fudge factor for separators and error checking. final int overhead = commandPrefix.length() + 100; for (List<String> rmArgs : chunkArgs(filesToDelete.build(), MAX_ADB_COMMAND_SIZE - overhead)) { String command = commandPrefix + Joiner.on(' ').join(rmArgs); LOG.debug("Executing %s", command); AdbHelper.executeCommandWithErrorChecking(device, command); } return foundHashes.build(); } }
/** * Creates a new environment. * * @param configuration the service's {@link Configuration} * @param service the service */ public Environment(Configuration configuration, AbstractService<?> service) { this.service = service; this.config = new DropwizardResourceConfig() { @Override public void validate() { super.validate(); logResources(); logProviders(); logHealthChecks(); logManagedObjects(); logEndpoints(); } }; this.healthChecks = ImmutableSet.builder(); this.servlets = ImmutableMap.builder(); this.filters = ImmutableMultimap.builder(); this.servletListeners = ImmutableSet.builder(); this.tasks = ImmutableSet.builder(); this.lifeCycle = new AggregateLifeCycle(); final HttpServlet jerseyContainer = service.getJerseyContainer(config); if (jerseyContainer != null) { addServlet(jerseyContainer, configuration.getHttpConfiguration().getRootPath()) .setInitOrder(Integer.MAX_VALUE); } addTask(new GarbageCollectionTask()); }
@Test public void upperBoundGenericTypesCauseValuesToBeSetToTheUpperBound() throws ConstructorArgMarshalException, NoSuchBuildTargetException { class Dto { public List<? extends SourcePath> yup; } ProjectFilesystem projectFilesystem = new FakeProjectFilesystem(); SourcePathResolver pathResolver = new SourcePathResolver(new BuildRuleResolver()); BuildRule rule = new FakeBuildRule(BuildTargetFactory.newInstance("//will:happen"), pathResolver); ruleResolver.addToIndex(rule); Dto dto = new Dto(); marshaller.populate( createCellRoots(filesystem), filesystem, buildRuleFactoryParams(), dto, ImmutableSet.<BuildTarget>builder(), ImmutableSet.<BuildTargetPattern>builder(), ImmutableMap.<String, Object>of( "yup", ImmutableList.of(rule.getBuildTarget().getFullyQualifiedName()))); BuildTargetSourcePath path = new BuildTargetSourcePath(rule.getBuildTarget()); assertEquals(ImmutableList.of(path), dto.yup); }
/** * Returns the ShellCommand object that is supposed to generate a code coverage report from data * obtained during the test run. This method will also generate a set of source paths to the class * files tested during the test run. */ private static Step getReportCommand( ImmutableSet<JavaLibrary> rulesUnderTest, Optional<DefaultJavaPackageFinder> defaultJavaPackageFinderOptional, ProjectFilesystem filesystem, Path outputDirectory, CoverageReportFormat format) { ImmutableSet.Builder<String> srcDirectories = ImmutableSet.builder(); ImmutableSet.Builder<Path> pathsToClasses = ImmutableSet.builder(); // Add all source directories of java libraries that we are testing to -sourcepath. for (JavaLibrary rule : rulesUnderTest) { ImmutableSet<String> sourceFolderPath = getPathToSourceFolders(rule, defaultJavaPackageFinderOptional, filesystem); if (!sourceFolderPath.isEmpty()) { srcDirectories.addAll(sourceFolderPath); } Path pathToOutput = rule.getPathToOutput(); if (pathToOutput == null) { continue; } pathsToClasses.add(pathToOutput); } return new GenerateCodeCoverageReportStep( srcDirectories.build(), pathsToClasses.build(), outputDirectory, format); }
@Test public void fieldsWithIsDepEqualsFalseHintAreNotTreatedAsDeps() throws ConstructorArgMarshalException, NoSuchBuildTargetException { class Dto { @Hint(isDep = false) public Optional<Set<BuildTarget>> deps; } final String dep = "//should/be:ignored"; Dto dto = new Dto(); Map<String, Object> args = Maps.newHashMap(); args.put("deps", ImmutableList.of(dep)); ImmutableSet.Builder<BuildTarget> declaredDeps = ImmutableSet.builder(); marshaller.populate( createCellRoots(filesystem), filesystem, buildRuleFactoryParams(), dto, declaredDeps, ImmutableSet.<BuildTargetPattern>builder(), args); assertEquals(ImmutableSet.of(), declaredDeps.build()); }
public void shouldSetBuildTargetParameters() throws ConstructorArgMarshalException, NoSuchBuildTargetException { class Dto { public BuildTarget single; public BuildTarget sameBuildFileTarget; public List<BuildTarget> targets; } Dto dto = new Dto(); marshaller.populate( createCellRoots(filesystem), filesystem, buildRuleFactoryParams(), dto, ImmutableSet.<BuildTarget>builder(), ImmutableSet.<BuildTargetPattern>builder(), ImmutableMap.<String, Object>of( "single", "//com/example:cheese", "sameBuildFileTarget", ":cake", "targets", ImmutableList.of(":cake", "//com/example:cheese"))); BuildTarget cheese = BuildTargetFactory.newInstance("//com/example:cheese"); BuildTarget cake = BuildTargetFactory.newInstance("//example/path:cake"); assertEquals(cheese, dto.single); assertEquals(cake, dto.sameBuildFileTarget); assertEquals(ImmutableList.of(cake, cheese), dto.targets); }
@Test public void onlyFieldNamedDepsAreConsideredDeclaredDeps() throws ConstructorArgMarshalException, NoSuchBuildTargetException { class Dto { public Optional<Set<BuildTarget>> deps; public Optional<Set<BuildTarget>> notdeps; } final String dep = "//is/a/declared:dep"; final String notDep = "//is/not/a/declared:dep"; BuildTarget declaredDep = BuildTargetFactory.newInstance(dep); Dto dto = new Dto(); Map<String, Object> args = Maps.newHashMap(); args.put("deps", ImmutableList.of(dep)); args.put("notdeps", ImmutableList.of(notDep)); ImmutableSet.Builder<BuildTarget> declaredDeps = ImmutableSet.builder(); marshaller.populate( createCellRoots(filesystem), filesystem, buildRuleFactoryParams(), dto, declaredDeps, ImmutableSet.<BuildTargetPattern>builder(), args); assertEquals(ImmutableSet.of(declaredDep), declaredDeps.build()); }
@Test public void shouldPopulateSourcePaths() throws ConstructorArgMarshalException, NoSuchBuildTargetException { class Dto { public SourcePath filePath; public SourcePath targetPath; } ProjectFilesystem projectFilesystem = new FakeProjectFilesystem(); BuildTarget target = BuildTargetFactory.newInstance("//example/path:peas"); FakeBuildRule rule = new FakeBuildRule(target, new SourcePathResolver(new BuildRuleResolver())); ruleResolver.addToIndex(rule); Dto dto = new Dto(); marshaller.populate( createCellRoots(filesystem), filesystem, buildRuleFactoryParams(), dto, ImmutableSet.<BuildTarget>builder(), ImmutableSet.<BuildTargetPattern>builder(), ImmutableMap.<String, Object>of( "filePath", "cheese.txt", "targetPath", ":peas")); assertEquals( new PathSourcePath(projectFilesystem, Paths.get("example/path/cheese.txt")), dto.filePath); assertEquals(new BuildTargetSourcePath(rule.getBuildTarget()), dto.targetPath); }
@Override public PlanNode visitIndexJoin(IndexJoinNode node, RewriteContext<Set<Symbol>> context) { ImmutableSet.Builder<Symbol> probeInputsBuilder = ImmutableSet.builder(); probeInputsBuilder .addAll(context.get()) .addAll(Iterables.transform(node.getCriteria(), IndexJoinNode.EquiJoinClause::getProbe)); if (node.getProbeHashSymbol().isPresent()) { probeInputsBuilder.add(node.getProbeHashSymbol().get()); } Set<Symbol> probeInputs = probeInputsBuilder.build(); ImmutableSet.Builder<Symbol> indexInputBuilder = ImmutableSet.builder(); indexInputBuilder .addAll(context.get()) .addAll(Iterables.transform(node.getCriteria(), IndexJoinNode.EquiJoinClause::getIndex)); if (node.getIndexHashSymbol().isPresent()) { indexInputBuilder.add(node.getIndexHashSymbol().get()); } Set<Symbol> indexInputs = indexInputBuilder.build(); PlanNode probeSource = context.rewrite(node.getProbeSource(), probeInputs); PlanNode indexSource = context.rewrite(node.getIndexSource(), indexInputs); return new IndexJoinNode( node.getId(), node.getType(), probeSource, indexSource, node.getCriteria(), node.getProbeHashSymbol(), node.getIndexHashSymbol()); }
@Override public PlanNode visitSemiJoin(SemiJoinNode node, RewriteContext<Set<Symbol>> context) { ImmutableSet.Builder<Symbol> sourceInputsBuilder = ImmutableSet.builder(); sourceInputsBuilder.addAll(context.get()).add(node.getSourceJoinSymbol()); if (node.getSourceHashSymbol().isPresent()) { sourceInputsBuilder.add(node.getSourceHashSymbol().get()); } Set<Symbol> sourceInputs = sourceInputsBuilder.build(); ImmutableSet.Builder<Symbol> filteringSourceInputBuilder = ImmutableSet.builder(); filteringSourceInputBuilder.add(node.getFilteringSourceJoinSymbol()); if (node.getFilteringSourceHashSymbol().isPresent()) { filteringSourceInputBuilder.add(node.getFilteringSourceHashSymbol().get()); } Set<Symbol> filteringSourceInputs = filteringSourceInputBuilder.build(); PlanNode source = context.rewrite(node.getSource(), sourceInputs); PlanNode filteringSource = context.rewrite(node.getFilteringSource(), filteringSourceInputs); return new SemiJoinNode( node.getId(), source, filteringSource, node.getSourceJoinSymbol(), node.getFilteringSourceJoinSymbol(), node.getSemiJoinOutput(), node.getSourceHashSymbol(), node.getFilteringSourceHashSymbol()); }
@Override public PlanNode visitJoin(JoinNode node, RewriteContext<Set<Symbol>> context) { ImmutableSet.Builder<Symbol> leftInputsBuilder = ImmutableSet.builder(); leftInputsBuilder .addAll(context.get()) .addAll(Iterables.transform(node.getCriteria(), JoinNode.EquiJoinClause::getLeft)); if (node.getLeftHashSymbol().isPresent()) { leftInputsBuilder.add(node.getLeftHashSymbol().get()); } Set<Symbol> leftInputs = leftInputsBuilder.build(); ImmutableSet.Builder<Symbol> rightInputsBuilder = ImmutableSet.builder(); rightInputsBuilder .addAll(context.get()) .addAll(Iterables.transform(node.getCriteria(), JoinNode.EquiJoinClause::getRight)); if (node.getRightHashSymbol().isPresent()) { rightInputsBuilder.add(node.getRightHashSymbol().get()); } Set<Symbol> rightInputs = rightInputsBuilder.build(); PlanNode left = context.rewrite(node.getLeft(), leftInputs); PlanNode right = context.rewrite(node.getRight(), rightInputs); return new JoinNode( node.getId(), node.getType(), left, right, node.getCriteria(), node.getLeftHashSymbol(), node.getRightHashSymbol()); }
static { ImmutableSet.Builder<Double> integralBuilder = ImmutableSet.builder(); ImmutableSet.Builder<Double> fractionalBuilder = ImmutableSet.builder(); integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE)); // Add small multiples of MIN_VALUE and MIN_NORMAL for (int scale = 1; scale <= 4; scale++) { for (double d : Doubles.asList(Double.MIN_VALUE, Double.MIN_NORMAL)) { fractionalBuilder.add(d * scale).add(-d * scale); } } for (double d : Doubles.asList( 0, 1, 2, 7, 51, 102, Math.scalb(1.0, 53), Integer.MIN_VALUE, Integer.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE)) { for (double delta : Doubles.asList(0.0, 1.0, 2.0)) { integralBuilder.addAll(Doubles.asList(d + delta, d - delta, -d - delta, -d + delta)); } for (double delta : Doubles.asList(0.01, 0.1, 0.25, 0.499, 0.5, 0.501, 0.7, 0.8)) { double x = d + delta; if (x != Math.round(x)) { fractionalBuilder.add(x); } } } INTEGRAL_DOUBLE_CANDIDATES = integralBuilder.build(); fractionalBuilder.add(1.414).add(1.415).add(Math.sqrt(2)); fractionalBuilder.add(5.656).add(5.657).add(4 * Math.sqrt(2)); for (double d : INTEGRAL_DOUBLE_CANDIDATES) { double x = 1 / d; if (x != Math.rint(x)) { fractionalBuilder.add(x); } } FRACTIONAL_DOUBLE_CANDIDATES = fractionalBuilder.build(); FINITE_DOUBLE_CANDIDATES = Iterables.concat(FRACTIONAL_DOUBLE_CANDIDATES, INTEGRAL_DOUBLE_CANDIDATES); POSITIVE_FINITE_DOUBLE_CANDIDATES = Iterables.filter( FINITE_DOUBLE_CANDIDATES, new Predicate<Double>() { @Override public boolean apply(Double input) { return input.doubleValue() > 0.0; } }); DOUBLE_CANDIDATES_EXCEPT_NAN = Iterables.concat(FINITE_DOUBLE_CANDIDATES, INFINITIES); ALL_DOUBLE_CANDIDATES = Iterables.concat(DOUBLE_CANDIDATES_EXCEPT_NAN, asList(Double.NaN)); }
static Set<UUID> extractIndexes(List<ShardIndexInfo> inputShards, int... indexes) { ImmutableSet.Builder<UUID> builder = ImmutableSet.builder(); for (int index : indexes) { builder.add(inputShards.get(index).getShardUuid()); } return builder.build(); }
/** * Returns the configurable attribute conditions necessary to evaluate the given configured * target, or null if not all dependencies have yet been SkyFrame-evaluated. */ @Nullable private Set<ConfigMatchingProvider> getConfigurableAttributeConditions( TargetAndConfiguration ctg, Environment env) { if (!(ctg.getTarget() instanceof Rule)) { return ImmutableSet.of(); } Rule rule = (Rule) ctg.getTarget(); RawAttributeMapper mapper = RawAttributeMapper.of(rule); Set<SkyKey> depKeys = new LinkedHashSet<>(); for (Attribute attribute : rule.getAttributes()) { for (Label label : mapper.getConfigurabilityKeys(attribute.getName(), attribute.getType())) { if (!BuildType.Selector.isReservedLabel(label)) { depKeys.add(ConfiguredTargetValue.key(label, ctg.getConfiguration())); } } } Map<SkyKey, SkyValue> cts = env.getValues(depKeys); if (env.valuesMissing()) { return null; } ImmutableSet.Builder<ConfigMatchingProvider> conditions = ImmutableSet.builder(); for (SkyValue ctValue : cts.values()) { ConfiguredTarget ct = ((ConfiguredTargetValue) ctValue).getConfiguredTarget(); conditions.add(Preconditions.checkNotNull(ct.getProvider(ConfigMatchingProvider.class))); } return conditions.build(); }
static { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (TrackerFilterEnum eventFilter : TrackerFilterEnum.values()) { builder.add(eventFilter.getValue()); } valuesSet = builder.build(); }
private void logManagedObjects() { final ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (Object bean : lifeCycle.getBeans()) { builder.add(bean.getClass().getCanonicalName()); } LOG.debug("managed objects = {}", builder.build()); }
private void logHealthChecks() { final ImmutableSet.Builder<String> builder = ImmutableSet.builder(); for (HealthCheck healthCheck : healthChecks.build()) { builder.add(healthCheck.getClass().getCanonicalName()); } LOG.debug("health checks = {}", builder.build()); }
public ImmutableSet<CxxInferCapture> createInferCaptureBuildRules( ImmutableMap<String, CxxSource> sources, CxxInferTools inferTools, CxxInferSourceFilter sourceFilter) { ImmutableSet.Builder<CxxInferCapture> objects = ImmutableSet.builder(); for (Map.Entry<String, CxxSource> entry : sources.entrySet()) { String name = entry.getKey(); CxxSource source = entry.getValue(); Preconditions.checkState( CxxSourceTypes.isPreprocessableType(source.getType()), "Only preprocessable source types are currently supported"); if (sourceFilter.isBlacklisted(source)) { continue; } CxxInferCapture rule = requireInferCaptureBuildRule(name, source, inferTools); objects.add(rule); } return objects.build(); }
/** * Helper to add srcs and deps Soy files to a SoyFileSet builder. Also does sanity checks. * * @param sfsBuilder The SoyFileSet builder to add to. * @param inputPrefix The input path prefix to prepend to all the file paths. * @param srcs The srcs from the --srcs flag. Exactly one of 'srcs' and 'args' must be nonempty. * @param args The old-style srcs from the command line (that's how they were specified before we * added the --srcs flag). Exactly one of 'srcs' and 'args' must be nonempty. * @param deps The deps from the --deps flag, or empty list if not applicable. * @param exitWithErrorFn A function that exits with an error message followed by a usage message. */ static void addSoyFilesToBuilder( Builder sfsBuilder, String inputPrefix, Collection<String> srcs, Collection<String> args, Collection<String> deps, Collection<String> indirectDeps, Function<String, Void> exitWithErrorFn) { if (srcs.isEmpty() && args.isEmpty()) { exitWithErrorFn.apply("Must provide list of source Soy files (--srcs)."); } if (!srcs.isEmpty() && !args.isEmpty()) { exitWithErrorFn.apply( "Found source Soy files from --srcs and from args (please use --srcs only)."); } // Create Set versions of each of the arguments, and de-dupe. If something is included as // multiple file kinds, we'll keep the strongest one; a file in both srcs and deps will be a // src, and one in both deps and indirect_deps will be a dep. // TODO(gboyer): Maybe stop supporting old style (srcs from command line args) at some point. Set<String> srcsSet = ImmutableSet.<String>builder().addAll(srcs).addAll(args).build(); Set<String> depsSet = Sets.difference(ImmutableSet.copyOf(deps), srcsSet); Set<String> indirectDepsSet = Sets.difference(ImmutableSet.copyOf(indirectDeps), Sets.union(srcsSet, depsSet)); for (String src : srcsSet) { sfsBuilder.addWithKind(new File(inputPrefix + src), SoyFileKind.SRC); } for (String dep : depsSet) { sfsBuilder.addWithKind(new File(inputPrefix + dep), SoyFileKind.DEP); } for (String dep : indirectDepsSet) { sfsBuilder.addWithKind(new File(inputPrefix + dep), SoyFileKind.INDIRECT_DEP); } }
@VisibleForTesting public Set<String> getSecurityGroupsForTagAndOptions( String region, @Nullable String group, TemplateOptions options) { Builder<String> groups = ImmutableSet.builder(); if (group != null) { String markerGroup = namingConvention.create().sharedNameForGroup(group); groups.add(markerGroup); RegionNameAndIngressRules regionNameAndIngressRulesForMarkerGroup; if (userSpecifiedTheirOwnGroups(options)) { regionNameAndIngressRulesForMarkerGroup = new RegionNameAndIngressRules(region, markerGroup, new int[] {}, false); groups.addAll(EC2TemplateOptions.class.cast(options).getGroups()); } else { regionNameAndIngressRulesForMarkerGroup = new RegionNameAndIngressRules(region, markerGroup, options.getInboundPorts(), true); } // this will create if not yet exists. securityGroupMap.getUnchecked(regionNameAndIngressRulesForMarkerGroup); } return groups.build(); }
@Test public void testGetJobUpdateDiffWithUpdateRemove() throws Exception { TaskConfig task1 = defaultTask(false).setNumCpus(1.0); TaskConfig task2 = defaultTask(false).setNumCpus(2.0); TaskConfig task3 = defaultTask(false).setNumCpus(3.0); ImmutableSet.Builder<IScheduledTask> tasks = ImmutableSet.builder(); makeTasks(0, 10, task1, tasks); makeTasks(10, 20, task2, tasks); makeTasks(20, 30, task3, tasks); expect(storageUtil.jobStore.fetchJob(JOB_KEY)).andReturn(Optional.absent()); storageUtil.expectTaskFetch(Query.jobScoped(JOB_KEY).active(), tasks.build()); control.replay(); JobUpdateRequest request = new JobUpdateRequest() .setTaskConfig(defaultTask(false).setNumCpus(6.0)) .setInstanceCount(20) .setSettings(new JobUpdateSettings()); GetJobUpdateDiffResult expected = new GetJobUpdateDiffResult() .setRemove(ImmutableSet.of(group(task3, new Range(20, 29)))) .setUpdate( ImmutableSet.of(group(task1, new Range(0, 9)), group(task2, new Range(10, 19)))) .setAdd(ImmutableSet.of()) .setUnchanged(ImmutableSet.of()); Response response = assertOkResponse(thrift.getJobUpdateDiff(request)); assertEquals(expected, response.getResult().getGetJobUpdateDiffResult()); }
@Override public Set<Integer> getPortsUsed() { return ImmutableSet.<Integer>builder() .addAll(super.getPortsUsed()) .addAll(getPortMap().values()) .build(); }
/** * Returns the context for a LIPO compile action. This uses the include dirs and defines of the * library, but the declared inclusion dirs/srcs from both the library and the owner binary. * * <p>TODO(bazel-team): this might make every LIPO target have an unnecessary large set of * inclusion dirs/srcs. The correct behavior would be to merge only the contexts of actual * referred targets (as listed in .imports file). * * <p>Undeclared inclusion checking ({@link #getDeclaredIncludeDirs()}, {@link * #getDeclaredIncludeWarnDirs()}, and {@link #getDeclaredIncludeSrcs()}) needs to use the union * of the contexts of the involved source files. * * <p>For include and define command line flags ({@link #getIncludeDirs()} {@link * #getQuoteIncludeDirs()}, {@link #getSystemIncludeDirs()}, and {@link #getDefines()}) LIPO * compilations use the same values as non-LIPO compilation. * * <p>Include scanning is not handled by this method. See {@code * IncludeScannable#getAuxiliaryScannables()} instead. * * @param ownerContext the compilation context of the owner binary * @param libContext the compilation context of the library */ public static CppCompilationContext mergeForLipo( CppCompilationContext ownerContext, CppCompilationContext libContext) { ImmutableSet.Builder<Artifact> prerequisites = ImmutableSet.builder(); prerequisites.addAll(ownerContext.compilationPrerequisites); prerequisites.addAll(libContext.compilationPrerequisites); ModuleInfo.Builder moduleInfo = new ModuleInfo.Builder(); moduleInfo.merge(ownerContext.moduleInfo); moduleInfo.merge(libContext.moduleInfo); ModuleInfo.Builder picModuleInfo = new ModuleInfo.Builder(); picModuleInfo.merge(ownerContext.picModuleInfo); picModuleInfo.merge(libContext.picModuleInfo); return new CppCompilationContext( libContext.commandLineContext, prerequisites.build(), mergeSets(ownerContext.declaredIncludeDirs, libContext.declaredIncludeDirs), mergeSets(ownerContext.declaredIncludeWarnDirs, libContext.declaredIncludeWarnDirs), mergeSets(ownerContext.declaredIncludeSrcs, libContext.declaredIncludeSrcs), mergeSets(ownerContext.pregreppedHdrs, libContext.pregreppedHdrs), moduleInfo.build(), picModuleInfo.build(), mergeSets(ownerContext.transitiveModuleMaps, libContext.transitiveModuleMaps), mergeSets(ownerContext.directModuleMaps, libContext.directModuleMaps), libContext.cppModuleMap, libContext.provideTransitiveModuleMaps, libContext.useHeaderModules); }
private ImmutableSet<AspectWithParameters> requiredAspects( AspectDefinition aspectDefinition, AspectParameters aspectParameters, Attribute attribute, Target target, Rule originalRule) { if (!(target instanceof Rule)) { return ImmutableSet.of(); } Set<AspectWithParameters> aspectCandidates = extractAspectCandidates(aspectDefinition, aspectParameters, attribute, originalRule); RuleClass ruleClass = ((Rule) target).getRuleClassObject(); ImmutableSet.Builder<AspectWithParameters> result = ImmutableSet.builder(); for (AspectWithParameters candidateClass : aspectCandidates) { ConfiguredAspectFactory candidate = (ConfiguredAspectFactory) AspectFactory.Util.create(candidateClass.getAspectFactory()); if (Sets.difference( candidate.getDefinition().getRequiredProviders(), ruleClass.getAdvertisedProviders()) .isEmpty()) { result.add(candidateClass); } } return result.build(); }
@VisibleForTesting List<Module> createModulesForProjectConfigs() throws IOException { DependencyGraph dependencyGraph = partialGraph.getDependencyGraph(); List<Module> modules = Lists.newArrayList(); // Convert the project_config() targets into modules and find the union of all jars passed to // no_dx. ImmutableSet.Builder<Path> noDxJarsBuilder = ImmutableSet.builder(); for (BuildTarget target : partialGraph.getTargets()) { BuildRule buildRule = dependencyGraph.findBuildRuleByTarget(target); ProjectConfig projectConfig = (ProjectConfig) buildRule.getBuildable(); BuildRule srcRule = projectConfig.getSrcRule(); if (srcRule != null) { Buildable buildable = srcRule.getBuildable(); if (buildable instanceof AndroidBinary) { AndroidBinary androidBinary = (AndroidBinary) buildable; AndroidDexTransitiveDependencies binaryDexTransitiveDependencies = androidBinary.findDexTransitiveDependencies(); noDxJarsBuilder.addAll(binaryDexTransitiveDependencies.noDxClasspathEntries); } } Module module = createModuleForProjectConfig(projectConfig); modules.add(module); } ImmutableSet<Path> noDxJars = noDxJarsBuilder.build(); // Update module dependencies to apply scope="PROVIDED", where appropriate. markNoDxJarsAsProvided(modules, noDxJars); return modules; }
public static Set<Sort> of(Collection<org.kframework.kil.Sort> sorts) { ImmutableSet.Builder<Sort> builder = ImmutableSet.builder(); for (org.kframework.kil.Sort name : sorts) { builder.add(Sort.of(name.getName())); } return builder.build(); }
static { ImmutableSet.Builder<Integer> intValues = ImmutableSet.builder(); // Add boundary values manually to avoid over/under flow (this covers 2^N for 0 and 31). intValues.add(Integer.MAX_VALUE - 1, Integer.MAX_VALUE); // Add values up to 40. This covers cases like "square of a prime" and such. for (int i = 1; i <= 40; i++) { intValues.add(i); } // Now add values near 2^N for lots of values of N. for (int exponent : asList(2, 3, 4, 9, 15, 16, 17, 24, 25, 30)) { int x = 1 << exponent; intValues.add(x, x + 1, x - 1); } intValues.add(9999).add(10000).add(10001).add(1000000); // near powers of 10 intValues.add(5792).add(5793); // sqrt(2^25) rounded up and down POSITIVE_INTEGER_CANDIDATES = intValues.build(); NEGATIVE_INTEGER_CANDIDATES = ImmutableList.copyOf( Iterables.concat( Iterables.transform(POSITIVE_INTEGER_CANDIDATES, NEGATE_INT), ImmutableList.of(Integer.MIN_VALUE))); NONZERO_INTEGER_CANDIDATES = ImmutableList.copyOf( Iterables.concat(POSITIVE_INTEGER_CANDIDATES, NEGATIVE_INTEGER_CANDIDATES)); ALL_INTEGER_CANDIDATES = Iterables.concat(NONZERO_INTEGER_CANDIDATES, ImmutableList.of(0)); }
protected Builder() { id("rackspace-cloudblockstorage-us") .name("Rackspace Next Generation Cloud Block Storage US") .apiMetadata( new CinderApiMetadata() .toBuilder() .identityName("${userName}") .credentialName("${apiKey}") .defaultEndpoint("https://identity.api.rackspacecloud.com/v2.0/") .endpointName("identity service url ending in /v2.0/") .documentation( URI.create( "http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/overview.html")) .defaultModules( ImmutableSet.<Class<? extends Module>>builder() .add(CloudIdentityAuthenticationApiModule.class) .add(CloudIdentityAuthenticationModule.class) .add(RegionModule.class) .add(CinderParserModule.class) .add(CinderHttpApiModule.class) .build()) .build()) .homepage(URI.create("http://www.rackspace.com/cloud/public/blockstorage/")) .console(URI.create("https://mycloud.rackspace.com")) .linkedServices("rackspace-cloudservers-us", "cloudfiles-us") .iso3166Codes("US-IL", "US-TX", "AU-NSW") .endpoint("https://identity.api.rackspacecloud.com/v2.0/") .defaultProperties(CloudBlockStorageUSProviderMetadata.defaultProperties()); }
@Override public AnswerKey apply(AnswerKey input) { final Set<Response> existingResponses = Sets.newHashSet(input.allResponses()); final ImmutableSet.Builder<AssessedResponse> newAssessedResponses = ImmutableSet.builder(); newAssessedResponses.addAll(input.annotatedResponses()); for (final AssessedResponse assessedResponse : input.annotatedResponses()) { if (assessedResponse.assessment().realis().isPresent()) { final Response responseWithAssessedRealis = assessedResponse .response() .copyWithSwappedRealis(assessedResponse.assessment().realis().get()); if (!existingResponses.contains(responseWithAssessedRealis)) { newAssessedResponses.add( AssessedResponse.from(responseWithAssessedRealis, assessedResponse.assessment())); existingResponses.add(responseWithAssessedRealis); } } } return AnswerKey.from( input.docId(), newAssessedResponses.build(), input.unannotatedResponses(), input.corefAnnotation()); }
public Collection<ITrait> getAllTraits() { ImmutableSet.Builder<ITrait> builder = ImmutableSet.builder(); for (List<ITrait> traitlist : traits.values()) { builder.addAll(traitlist); } return builder.build(); }