private PlanBuilder appendProjections(PlanBuilder subPlan, Iterable<Expression> expressions) {
TranslationMap translations = new TranslationMap(subPlan.getRelationPlan(), analysis);
// Carry over the translations from the source because we are appending projections
translations.copyMappingsFrom(subPlan.getTranslations());
ImmutableMap.Builder<Symbol, Expression> projections = ImmutableMap.builder();
// add an identity projection for underlying plan
for (Symbol symbol : subPlan.getRoot().getOutputSymbols()) {
Expression expression = new QualifiedNameReference(symbol.toQualifiedName());
projections.put(symbol, expression);
}
ImmutableMap.Builder<Symbol, Expression> newTranslations = ImmutableMap.builder();
for (Expression expression : expressions) {
Symbol symbol = symbolAllocator.newSymbol(expression, analysis.getType(expression));
// TODO: CHECK IF THE REWRITE OF A SEMI JOINED EXPRESSION WILL WORK!!!!!!!
projections.put(symbol, translations.rewrite(expression));
newTranslations.put(symbol, expression);
}
// Now append the new translations into the TranslationMap
for (Map.Entry<Symbol, Expression> entry : newTranslations.build().entrySet()) {
translations.put(entry.getValue(), entry.getKey());
}
return new PlanBuilder(
translations,
new ProjectNode(idAllocator.getNextId(), subPlan.getRoot(), projections.build()),
subPlan.getSampleWeight());
}
public SoySauceImpl create(
CompiledTemplates templates,
ImmutableMap<String, ? extends SoyFunction> soyFunctionMap,
ImmutableMap<String, ? extends SoyPrintDirective> printDirectives) {
// SoySauce has no need for SoyFunctions that are not SoyJavaFunctions
// (it generates Java source code implementing BuiltinFunctions).
// Filter them out.
ImmutableMap.Builder<String, SoyJavaFunction> soyJavaFunctions = ImmutableMap.builder();
for (Map.Entry<String, ? extends SoyFunction> entry : soyFunctionMap.entrySet()) {
SoyFunction function = entry.getValue();
if (function instanceof SoyJavaFunction) {
soyJavaFunctions.put(entry.getKey(), (SoyJavaFunction) function);
}
}
// SoySauce has no need for SoyPrintDirectives that are not SoyJavaPrintDirectives.
// Filter them out.
ImmutableMap.Builder<String, SoyJavaPrintDirective> soyJavaPrintDirectives =
ImmutableMap.builder();
for (Map.Entry<String, ? extends SoyPrintDirective> entry : printDirectives.entrySet()) {
SoyPrintDirective printDirective = entry.getValue();
if (printDirective instanceof SoyJavaPrintDirective) {
soyJavaPrintDirectives.put(entry.getKey(), (SoyJavaPrintDirective) printDirective);
}
}
return new SoySauceImpl(
templates,
apiCallScopeProvider,
converterProvider.get(),
soyJavaFunctions.build(),
soyJavaPrintDirectives.build());
}
private static ImmutableMap<String, String> getQueryMap(final String query)
throws MalformedRequestException {
if (StringUtils.isBlank(query)) {
return ImmutableMap.of();
} else {
final Iterable<String> params = Splitter.on('&').split(query);
final ImmutableMap.Builder<String, String> map = ImmutableMap.builder();
for (final String param : params) {
final ImmutableList<String> strings = ImmutableList.copyOf(Splitter.on('=').split(param));
final String name = strings.get(0);
if (strings.size() > 2) {
throw new MalformedRequestException("Multiple '=' for parameter " + name);
}
final String value;
if (strings.size() > 1) {
value = strings.get(1);
} else {
value = null;
}
if (map.build().keySet().contains(name)) {
throw new MalformedRequestException("Duplicate value for parameter " + name);
}
map.put(name, value);
}
return map.build();
}
}
public PlanBuilder appendProjections(
Iterable<Expression> expressions,
SymbolAllocator symbolAllocator,
PlanNodeIdAllocator idAllocator) {
TranslationMap translations = copyTranslations();
ImmutableMap.Builder<Symbol, Expression> projections = ImmutableMap.builder();
// add an identity projection for underlying plan
for (Symbol symbol : getRoot().getOutputSymbols()) {
projections.put(symbol, symbol.toSymbolReference());
}
ImmutableMap.Builder<Symbol, Expression> newTranslations = ImmutableMap.builder();
ParameterRewriter parameterRewriter = new ParameterRewriter(parameters, getAnalysis());
for (Expression expression : expressions) {
Expression rewritten = ExpressionTreeRewriter.rewriteWith(parameterRewriter, expression);
translations.addIntermediateMapping(expression, rewritten);
Symbol symbol =
symbolAllocator.newSymbol(rewritten, getAnalysis().getTypeWithCoercions(expression));
projections.put(symbol, translations.rewrite(rewritten));
newTranslations.put(symbol, rewritten);
}
// Now append the new translations into the TranslationMap
for (Map.Entry<Symbol, Expression> entry : newTranslations.build().entrySet()) {
translations.put(entry.getValue(), entry.getKey());
}
return new PlanBuilder(
translations,
new ProjectNode(idAllocator.getNextId(), getRoot(), projections.build()),
parameters);
}
/**
* Produces a factory that allows the union of the grants, and intersects policies where they
* overlap on a particular granted attribute or element name.
*/
public PolicyFactory and(PolicyFactory f) {
ImmutableMap.Builder<String, ElementAndAttributePolicies> b = ImmutableMap.builder();
// Merge this and f into a map of element names to attribute policies.
for (Map.Entry<String, ElementAndAttributePolicies> e : policies.entrySet()) {
String elName = e.getKey();
ElementAndAttributePolicies p = e.getValue();
ElementAndAttributePolicies q = f.policies.get(elName);
if (q != null) {
p = p.and(q);
} else {
// Mix in any globals that are not already taken into account in this.
p = p.andGlobals(f.globalAttrPolicies);
}
b.put(elName, p);
}
// Handle keys that are in f but not in this.
for (Map.Entry<String, ElementAndAttributePolicies> e : f.policies.entrySet()) {
String elName = e.getKey();
if (!policies.containsKey(elName)) {
ElementAndAttributePolicies p = e.getValue();
// Mix in any globals that are not already taken into account in this.
p = p.andGlobals(f.globalAttrPolicies);
b.put(elName, p);
}
}
ImmutableSet<String> textContainers;
if (this.textContainers.containsAll(f.textContainers)) {
textContainers = this.textContainers;
} else if (f.textContainers.containsAll(this.textContainers)) {
textContainers = f.textContainers;
} else {
textContainers =
ImmutableSet.<String>builder()
.addAll(this.textContainers)
.addAll(f.textContainers)
.build();
}
ImmutableMap<String, AttributePolicy> allGlobalAttrPolicies;
if (f.globalAttrPolicies.isEmpty()) {
allGlobalAttrPolicies = this.globalAttrPolicies;
} else if (this.globalAttrPolicies.isEmpty()) {
allGlobalAttrPolicies = f.globalAttrPolicies;
} else {
ImmutableMap.Builder<String, AttributePolicy> ab = ImmutableMap.builder();
for (Map.Entry<String, AttributePolicy> e : this.globalAttrPolicies.entrySet()) {
String attrName = e.getKey();
ab.put(
attrName, AttributePolicy.Util.join(e.getValue(), f.globalAttrPolicies.get(attrName)));
}
for (Map.Entry<String, AttributePolicy> e : f.globalAttrPolicies.entrySet()) {
String attrName = e.getKey();
if (!this.globalAttrPolicies.containsKey(attrName)) {
ab.put(attrName, e.getValue());
}
}
allGlobalAttrPolicies = ab.build();
}
return new PolicyFactory(b.build(), textContainers, allGlobalAttrPolicies);
}
public SetMessagesResponse build() {
return new SetMessagesResponse(
accountId,
oldState,
newState,
created.build(),
updated.build(),
destroyed.build(),
notCreated.build(),
notUpdated.build(),
notDestroyed.build());
}
AllProjectRoles(Collection<ProjectRole> projectRoles) {
final ImmutableMap.Builder<Long, ProjectRole> byId = ImmutableMap.builder();
final ImmutableMap.Builder<String, ProjectRole> byName = ImmutableMap.builder();
for (ProjectRole projectRole : projectRoles) {
byId.put(projectRole.getId(), projectRole);
byName.put(projectRole.getName(), projectRole);
}
this.projectRoles = ImmutableList.copyOf(projectRoles);
this.projectRolesById = byId.build();
this.projectRolesByName = byName.build();
}
static {
final ImmutableMap.Builder<String, JavadocTagInfo> textToTagBuilder =
new ImmutableMap.Builder<>();
final ImmutableMap.Builder<String, JavadocTagInfo> nameToTagBuilder =
new ImmutableMap.Builder<>();
for (final JavadocTagInfo tag : JavadocTagInfo.values()) {
textToTagBuilder.put(tag.getText(), tag);
nameToTagBuilder.put(tag.getName(), tag);
}
TEXT_TO_TAG = textToTagBuilder.build();
NAME_TO_TAG = nameToTagBuilder.build();
}
@Override
public PlanNode visitWindow(WindowNode node, RewriteContext<Set<Symbol>> context) {
ImmutableSet.Builder<Symbol> expectedInputs =
ImmutableSet.<Symbol>builder()
.addAll(context.get())
.addAll(node.getPartitionBy())
.addAll(node.getOrderBy());
if (node.getFrame().getStartValue().isPresent()) {
expectedInputs.add(node.getFrame().getStartValue().get());
}
if (node.getFrame().getEndValue().isPresent()) {
expectedInputs.add(node.getFrame().getEndValue().get());
}
if (node.getHashSymbol().isPresent()) {
expectedInputs.add(node.getHashSymbol().get());
}
ImmutableMap.Builder<Symbol, Signature> functions = ImmutableMap.builder();
ImmutableMap.Builder<Symbol, FunctionCall> functionCalls = ImmutableMap.builder();
for (Map.Entry<Symbol, FunctionCall> entry : node.getWindowFunctions().entrySet()) {
Symbol symbol = entry.getKey();
if (context.get().contains(symbol)) {
FunctionCall call = entry.getValue();
expectedInputs.addAll(DependencyExtractor.extractUnique(call));
functionCalls.put(symbol, call);
functions.put(symbol, node.getSignatures().get(symbol));
}
}
PlanNode source = context.rewrite(node.getSource(), expectedInputs.build());
return new WindowNode(
node.getId(),
source,
node.getPartitionBy(),
node.getOrderBy(),
node.getOrderings(),
node.getFrame(),
functionCalls.build(),
functions.build(),
node.getHashSymbol(),
node.getPrePartitionedInputs(),
node.getPreSortedOrderPrefix());
}
private ImmutableMap<String, JdbcTable> computeTables() {
Connection connection = null;
ResultSet resultSet = null;
try {
connection = dataSource.getConnection();
DatabaseMetaData metaData = connection.getMetaData();
resultSet = metaData.getTables(catalog, schema, null, null);
final ImmutableMap.Builder<String, JdbcTable> builder = ImmutableMap.builder();
while (resultSet.next()) {
final String tableName = resultSet.getString(3);
final String catalogName = resultSet.getString(1);
final String schemaName = resultSet.getString(2);
final String tableTypeName = resultSet.getString(4);
// Clean up table type. In particular, this ensures that 'SYSTEM TABLE',
// returned by Phoenix among others, maps to TableType.SYSTEM_TABLE.
// We know enum constants are upper-case without spaces, so we can't
// make things worse.
final String tableTypeName2 = tableTypeName.toUpperCase().replace(' ', '_');
final TableType tableType = Util.enumVal(TableType.class, tableTypeName2);
final JdbcTable table = new JdbcTable(this, catalogName, schemaName, tableName, tableType);
builder.put(tableName, table);
}
return builder.build();
} catch (SQLException e) {
throw new RuntimeException("Exception while reading tables", e);
} finally {
close(connection, null, resultSet);
}
}
/** Unpacks the response from remote TF manager into this object. */
@Override
protected CommandResult unpackResponseFromJson(JSONObject json) throws JSONException {
Status status = Status.NOT_ALLOCATED;
FreeDeviceState state = FreeDeviceState.AVAILABLE;
String statusString = json.getString(STATUS);
try {
status = CommandResult.Status.valueOf(statusString);
} catch (IllegalArgumentException e) {
throw new JSONException(String.format("unrecognized status '%s'", statusString));
}
String errorDetails = json.optString(INVOCATION_ERROR, null);
String freeDeviceString = json.optString(FREE_DEVICE_STATE, null);
if (freeDeviceString != null) {
try {
state = FreeDeviceState.valueOf(freeDeviceString);
} catch (IllegalArgumentException e) {
throw new JSONException(String.format("unrecognized state '%s'", freeDeviceString));
}
}
Map<String, String> runMetricsMap = null;
JSONArray jsonRunMetricsArray = json.optJSONArray(RUN_METRICS);
if (jsonRunMetricsArray != null && jsonRunMetricsArray.length() > 0) {
ImmutableMap.Builder<String, String> mapBuilder = new ImmutableMap.Builder<String, String>();
for (int i = 0; i < jsonRunMetricsArray.length(); i++) {
JSONObject runMetricJson = jsonRunMetricsArray.getJSONObject(i);
final String key = runMetricJson.getString(RUN_METRICS_KEY);
final String value = runMetricJson.getString(RUN_METRICS_VALUE);
mapBuilder.put(key, value);
}
runMetricsMap = mapBuilder.build();
}
return new CommandResult(status, errorDetails, state, runMetricsMap);
}
private static ImmutableMap<String, JetToken> tokenSetToMap(TokenSet tokens) {
ImmutableMap.Builder<String, JetToken> builder = ImmutableMap.builder();
for (IElementType token : tokens.getTypes()) {
builder.put(token.toString(), (JetToken) token);
}
return builder.build();
}
public Map<String, Path> buildMultipleAndReturnOutputs(String... args) throws IOException {
// Add in `--show-output` to the build, so we can parse the output paths after the fact.
ImmutableList<String> buildArgs =
ImmutableList.<String>builder().add("--show-output").add(args).build();
ProjectWorkspace.ProcessResult buildResult =
runBuckBuild(buildArgs.toArray(new String[buildArgs.size()]));
buildResult.assertSuccess();
// Grab the stdout lines, which have the build outputs.
List<String> lines =
Splitter.on(CharMatcher.anyOf(System.lineSeparator()))
.trimResults()
.omitEmptyStrings()
.splitToList(buildResult.getStdout());
// Skip the first line, which is just "The outputs are:".
assertThat(lines.get(0), Matchers.equalTo("The outputs are:"));
lines = lines.subList(1, lines.size());
Splitter lineSplitter = Splitter.on(' ').trimResults();
ImmutableMap.Builder<String, Path> builder = ImmutableMap.builder();
for (String line : lines) {
List<String> fields = lineSplitter.splitToList(line);
assertThat(fields, Matchers.hasSize(2));
builder.put(fields.get(0), getPath(fields.get(1)));
}
return builder.build();
}
@Override
public JobModel from(UriInfo uriInfo, Job job) {
JobModel jobModel = new JobModel();
jobModel.setId(job.getId());
jobModel.setName(job.getJobName());
jobModel.setExternalIds(job.getExternalIds());
jobModel.setType(job.getJobType().name());
jobModel.setStatus(
new ResourceStatusModel(
job.getStatus().name(),
ZonedDateTime.ofInstant(job.getStatusTimestamp().toInstant(), ZoneId.systemDefault())));
jobModel.setPriority(job.getPriority());
jobModel.setCreated(
ZonedDateTime.ofInstant(job.getCreated().toInstant(), ZoneId.systemDefault()));
jobModel.setCreatedBy(job.getCreatedBy());
jobModel.setLastModified(
ZonedDateTime.ofInstant(job.getLastModified().toInstant(), ZoneId.systemDefault()));
jobModel.setLastModifiedBy(job.getLastModifiedBy());
ImmutableMap.Builder<String, Href> builder = ImmutableMap.builder();
builder.put("self", new Href(getJobResourceUrlAsString(uriInfo, job, null)));
builder.put(
"configuration", new Href(getJobResourceUrlAsString(uriInfo, job, "configuration")));
builder.put("status", new Href(getJobResourceUrlAsString(uriInfo, job, "status")));
jobModel.setLinks(builder.build());
return jobModel;
}
/**
* Convert this node tree into a map of the defined nodes in this tree.
*
* @return An immutable map representation of the nodes defined in this tree
*/
public Map<String, Integer> asMap() {
ImmutableMap.Builder<String, Integer> ret = ImmutableMap.builder();
for (Map.Entry<String, Node> ent : this.rootNode.children.entrySet()) {
populateMap(ret, ent.getKey(), ent.getValue());
}
return ret.build();
}
private static Map<FileLike, String> traverse(Collection<File> files) throws IOException {
Collection<Path> paths =
FluentIterable.from(files)
.transform(
new Function<File, Path>() {
@Override
public Path apply(File file) {
return file.toPath();
}
})
.toList();
final ImmutableMap.Builder<FileLike, String> completeList = ImmutableMap.builder();
ClasspathTraverser traverser = new DefaultClasspathTraverser();
ProjectFilesystem filesystem = new ProjectFilesystem(Paths.get(".").toAbsolutePath());
traverser.traverse(
new ClasspathTraversal(paths, filesystem) {
@Override
public void visit(FileLike fileLike) {
String contents;
try {
contents = new FileLikeCharSource(fileLike).read();
} catch (IOException e) {
throw Throwables.propagate(e);
}
completeList.put(fileLike, contents);
}
});
return completeList.build();
}
/**
* Creates a new attribute service using the given providers and user provided default attribute
* values.
*/
public AttributeService(
Iterable<? extends AttributeProvider> providers, Map<String, ?> userProvidedDefaults) {
ImmutableMap.Builder<String, AttributeProvider> byViewNameBuilder = ImmutableMap.builder();
ImmutableMap.Builder<Class<?>, AttributeProvider> byViewTypeBuilder = ImmutableMap.builder();
ImmutableMap.Builder<Class<?>, AttributeProvider> byAttributesTypeBuilder =
ImmutableMap.builder();
ImmutableList.Builder<FileAttribute<?>> defaultAttributesBuilder = ImmutableList.builder();
for (AttributeProvider provider : providers) {
byViewNameBuilder.put(provider.name(), provider);
byViewTypeBuilder.put(provider.viewType(), provider);
if (provider.attributesType() != null) {
byAttributesTypeBuilder.put(provider.attributesType(), provider);
}
for (Map.Entry<String, ?> entry : provider.defaultValues(userProvidedDefaults).entrySet()) {
defaultAttributesBuilder.add(new SimpleFileAttribute<>(entry.getKey(), entry.getValue()));
}
}
this.providersByName = byViewNameBuilder.build();
this.providersByViewType = byViewTypeBuilder.build();
this.providersByAttributesType = byAttributesTypeBuilder.build();
this.defaultValues = defaultAttributesBuilder.build();
}
public static Map<Long, ZoneId> listToMap(List<IdTimeZone> list) {
ImmutableMap.Builder<Long, ZoneId> builder = ImmutableMap.builder();
for (IdTimeZone pair : list) {
builder.put(pair.id, pair.timeZone);
}
return builder.build();
}
@Override
public ProjectMap getProjectsByIdList(List<Integer> projIdList) {
if (projIdList.isEmpty()) {
return ProjectMap.empty();
}
List<StoredProject> projs =
autoCommit(
(handle, dao) ->
handle
.createQuery(
"select * from projects"
+ " where site_id = :siteId"
+ " and id "
+ inLargeIdListExpression(projIdList))
.bind("siteId", siteId)
.map(new StoredProjectMapper(cfm))
.list());
ImmutableMap.Builder<Integer, StoredProject> builder = ImmutableMap.builder();
for (StoredProject proj : projs) {
builder.put(proj.getId(), proj);
}
return new ProjectMap(builder.build());
}
private ImmutableMap<Path, Path> getExpandedSourcePaths(
ExecutionContext context, ImmutableMap<Path, Path> paths) throws IOException {
ProjectFilesystem projectFilesystem = context.getProjectFilesystem();
ImmutableMap.Builder<Path, Path> sources = ImmutableMap.builder();
for (ImmutableMap.Entry<Path, Path> ent : paths.entrySet()) {
if (ent.getValue().toString().endsWith(SRC_ZIP)) {
Path destinationDirectory = projectFilesystem.resolve(tempDir.resolve(ent.getKey()));
Files.createDirectories(destinationDirectory);
ImmutableList<Path> zipPaths =
Unzip.extractZipFile(
projectFilesystem.resolve(ent.getValue()),
destinationDirectory,
Unzip.ExistingFileMode.OVERWRITE);
for (Path path : zipPaths) {
Path modulePath = destinationDirectory.relativize(path);
sources.put(modulePath, path);
}
} else {
sources.put(ent.getKey(), ent.getValue());
}
}
return sources.build();
}
/**
* Build a {@link HeaderSymlinkTree} of all the shared libraries found via the top-level rule's
* transitive dependencies.
*/
public static SymlinkTree createSharedLibrarySymlinkTree(
TargetGraph targetGraph,
BuildRuleParams params,
SourcePathResolver pathResolver,
CxxPlatform cxxPlatform,
Predicate<Object> traverse) {
BuildTarget symlinkTreeTarget =
createSharedLibrarySymlinkTreeTarget(params.getBuildTarget(), cxxPlatform.getFlavor());
Path symlinkTreeRoot =
getSharedLibrarySymlinkTreePath(params.getBuildTarget(), cxxPlatform.getFlavor());
ImmutableSortedMap<String, SourcePath> libraries =
NativeLinkables.getTransitiveSharedLibraries(
targetGraph, cxxPlatform, params.getDeps(), Linker.LinkableDepType.SHARED, traverse);
ImmutableMap.Builder<Path, SourcePath> links = ImmutableMap.builder();
for (Map.Entry<String, SourcePath> ent : libraries.entrySet()) {
links.put(Paths.get(ent.getKey()), ent.getValue());
}
try {
return new SymlinkTree(
params.copyWithChanges(
symlinkTreeTarget,
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of()),
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
pathResolver,
symlinkTreeRoot,
links.build());
} catch (SymlinkTree.InvalidSymlinkTreeException e) {
throw new RuntimeException(e.getMessage());
}
}
@Override
public IFlexibleBakedModel bake(
IModelState state,
VertexFormat format,
Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
IFlexibleBakedModel bakedBase = null;
if (base != null) bakedBase = base.bake(state, format, bakedTextureGetter);
ImmutableMap.Builder<String, IFlexibleBakedModel> mapBuilder = ImmutableMap.builder();
for (Entry<String, Pair<IModel, IModelState>> entry : parts.entrySet()) {
Pair<IModel, IModelState> pair = entry.getValue();
mapBuilder.put(
entry.getKey(), pair.getLeft().bake(pair.getRight(), format, bakedTextureGetter));
}
if (bakedBase == null && parts.isEmpty()) {
FMLLog.log(
Level.ERROR,
"MultiModel %s is empty (no base model or parts were provided/resolved)",
location);
IModel missing = ModelLoaderRegistry.getMissingModel();
return missing.bake(missing.getDefaultState(), format, bakedTextureGetter);
}
return new Baked(location, true, bakedBase, mapBuilder.build());
}
public FileDataCache(Iterable<FileData> fileData) {
ImmutableMap.Builder<String, byte[]> builder = ImmutableMap.builder();
for (FileData data : fileData) {
builder.put(data.getInfo().getDigest(), data.getContent().toByteArray());
}
fileContents = builder.build();
}
@Override
public Map<String, String> toMetadataRecord() {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
builder.put("id", getId());
if (getDisplayName() != null) builder.put("displayName", getDisplayName());
return builder.build();
}
public CxxTest(
BuildRuleParams params,
SourcePathResolver resolver,
final ImmutableMap<String, String> toolEnv,
final Supplier<ImmutableMap<String, String>> env,
Supplier<ImmutableList<String>> args,
ImmutableSortedSet<SourcePath> resources,
Supplier<ImmutableSortedSet<BuildRule>> additionalDeps,
ImmutableSet<Label> labels,
ImmutableSet<String> contacts,
boolean runTestSeparately,
Optional<Long> testRuleTimeoutMs) {
super(params, resolver);
this.env =
Suppliers.memoize(
() -> {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
builder.putAll(toolEnv);
builder.putAll(env.get());
return builder.build();
});
this.args = Suppliers.memoize(args);
this.resources = resources;
this.additionalDeps = Suppliers.memoize(additionalDeps);
this.labels = labels;
this.contacts = contacts;
this.runTestSeparately = runTestSeparately;
this.testRuleTimeoutMs = testRuleTimeoutMs;
}
// Using reflection gets all token names and values from JavadocTokenTypes class
// and saves to TOKEN_NAME_TO_VALUE and TOKEN_VALUE_TO_NAME collections.
static {
final ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
final Field[] fields = JavadocTokenTypes.class.getDeclaredFields();
String[] tempTokenValueToName = new String[0];
for (final Field f : fields) {
// Only process public int fields.
if (!Modifier.isPublic(f.getModifiers()) || f.getType() != Integer.TYPE) {
continue;
}
final String name = f.getName();
final int tokenValue = Utils.getIntFromField(f, name);
builder.put(name, tokenValue);
if (tokenValue > tempTokenValueToName.length - 1) {
final String[] temp = new String[tokenValue + 1];
System.arraycopy(tempTokenValueToName, 0, temp, 0, tempTokenValueToName.length);
tempTokenValueToName = temp;
}
if (tokenValue == -1) {
tempTokenValueToName[0] = name;
} else {
tempTokenValueToName[tokenValue] = name;
}
}
TOKEN_NAME_TO_VALUE = builder.build();
TOKEN_VALUE_TO_NAME = tempTokenValueToName;
}
private static ServicePorts of(final Iterable<String> ports) {
final ImmutableMap.Builder<String, ServicePortParameters> builder = ImmutableMap.builder();
for (final String port : ports) {
builder.put(port, new ServicePortParameters());
}
return new ServicePorts(builder.build());
}
@Test
public void extractSourcePaths() {
ImmutableSortedSet.Builder<SourcePath> files = ImmutableSortedSet.naturalOrder();
ImmutableMap.Builder<SourcePath, String> perFileCompileFlags = ImmutableMap.builder();
ImmutableList<Either<SourcePath, Pair<SourcePath, String>>> input =
ImmutableList.of(
newEntry("foo.m"),
newEntry("bar.m", "-flag1 -flag2"),
newEntry("baz.m"),
newEntry("quox.m", "-flag1"));
RuleUtils.extractSourcePaths(files, perFileCompileFlags, input);
assertEquals(
ImmutableSortedSet.<SourcePath>of(
new FileSourcePath("foo.m"),
new FileSourcePath("bar.m"),
new FileSourcePath("baz.m"),
new FileSourcePath("quox.m")),
files.build());
assertEquals(
ImmutableMap.<SourcePath, String>of(
new FileSourcePath("bar.m"), "-flag1 -flag2",
new FileSourcePath("quox.m"), "-flag1"),
perFileCompileFlags.build());
}
static {
ImmutableMap.Builder<String, GttCommand> builder = ImmutableMap.builder();
for (GttCommand command : GttCommand.values()) {
builder.put(command.name().toLowerCase(), command);
}
NAME_TO_COMMAND_MAP = builder.build();
}
public ImmutableMap<String, Method> build() {
final ImmutableMap.Builder<String, Method> lResultBuilder =
new ImmutableMap.Builder<String, Method>();
// iterate based on mMethodsOrdered to maintain
// the order
for (String lBeanPropName : mMethodsOrdered) {
final NavigableSet<Method> lAllMethods = mMethodCache.getUnchecked(lBeanPropName);
final Method lMostPreciseMethod = lAllMethods.last();
LOGGER.trace(
"propName [{}] selected method [{}] all methods[{}]",
new Object[] {lBeanPropName, lMostPreciseMethod, lAllMethods});
if (mBeanMethodFilter.accepts(lMostPreciseMethod, lBeanPropName)) {
lResultBuilder.put(lBeanPropName, lMostPreciseMethod);
} else {
LOGGER.trace("rejected [{}]", lBeanPropName);
}
}
return lResultBuilder.build();
}