use of com.google.common.collect.ImmutableListMultimap in project presto by prestodb.
the class InCodeGenerator method generateExpression.
@Override
public BytecodeNode generateExpression(BytecodeGeneratorContext generatorContext, Type returnType, List<RowExpression> arguments, Optional<Variable> outputBlockVariable) {
List<RowExpression> values = arguments.subList(1, arguments.size());
// empty IN statements are not allowed by the standard, and not possible here
// the implementation assumes this condition is always met
checkArgument(values.size() > 0, "values must not be empty");
Type type = arguments.get(0).getType();
Class<?> javaType = type.getJavaType();
SwitchGenerationCase switchGenerationCase = checkSwitchGenerationCase(type, values);
FunctionHandle hashCodeHandle = generatorContext.getFunctionManager().resolveOperator(HASH_CODE, fromTypes(type));
MethodHandle hashCodeFunction = generatorContext.getFunctionManager().getJavaScalarFunctionImplementation(hashCodeHandle).getMethodHandle();
FunctionHandle isIndeterminateHandle = generatorContext.getFunctionManager().resolveOperator(INDETERMINATE, fromTypes(type));
JavaScalarFunctionImplementation isIndeterminateFunction = generatorContext.getFunctionManager().getJavaScalarFunctionImplementation(isIndeterminateHandle);
ImmutableListMultimap.Builder<Integer, BytecodeNode> hashBucketsBuilder = ImmutableListMultimap.builder();
ImmutableList.Builder<BytecodeNode> defaultBucket = ImmutableList.builder();
ImmutableSet.Builder<Object> constantValuesBuilder = ImmutableSet.builder();
for (RowExpression testValue : values) {
BytecodeNode testBytecode = generatorContext.generate(testValue, Optional.empty());
if (isDeterminateConstant(testValue, isIndeterminateFunction.getMethodHandle())) {
ConstantExpression constant = (ConstantExpression) testValue;
Object object = constant.getValue();
switch(switchGenerationCase) {
case DIRECT_SWITCH:
case SET_CONTAINS:
constantValuesBuilder.add(object);
break;
case HASH_SWITCH:
try {
int hashCode = toIntExact(Long.hashCode((Long) hashCodeFunction.invoke(object)));
hashBucketsBuilder.put(hashCode, testBytecode);
} catch (Throwable throwable) {
throw new IllegalArgumentException("Error processing IN statement: error calculating hash code for " + object, throwable);
}
break;
default:
throw new IllegalArgumentException("Not supported switch generation case: " + switchGenerationCase);
}
} else {
defaultBucket.add(testBytecode);
}
}
ImmutableListMultimap<Integer, BytecodeNode> hashBuckets = hashBucketsBuilder.build();
ImmutableSet<Object> constantValues = constantValuesBuilder.build();
LabelNode end = new LabelNode("end");
LabelNode match = new LabelNode("match");
LabelNode noMatch = new LabelNode("noMatch");
LabelNode defaultLabel = new LabelNode("default");
Scope scope = generatorContext.getScope();
Variable value = scope.createTempVariable(javaType);
BytecodeNode switchBlock;
Variable expression = scope.createTempVariable(int.class);
SwitchBuilder switchBuilder = new SwitchBuilder().expression(expression);
switch(switchGenerationCase) {
case DIRECT_SWITCH:
// For these types, it's safe to not use presto HASH_CODE and EQUAL operator.
for (Object constantValue : constantValues) {
switchBuilder.addCase(toIntExact((Long) constantValue), jump(match));
}
switchBuilder.defaultCase(jump(defaultLabel));
switchBlock = new BytecodeBlock().comment("lookupSwitch(<stackValue>))").append(new IfStatement().condition(invokeStatic(InCodeGenerator.class, "isInteger", boolean.class, value)).ifFalse(new BytecodeBlock().gotoLabel(defaultLabel))).append(expression.set(value.cast(int.class))).append(switchBuilder.build());
break;
case HASH_SWITCH:
for (Map.Entry<Integer, Collection<BytecodeNode>> bucket : hashBuckets.asMap().entrySet()) {
Collection<BytecodeNode> testValues = bucket.getValue();
BytecodeBlock caseBlock = buildInCase(generatorContext, scope, type, match, defaultLabel, value, testValues, false, isIndeterminateFunction);
switchBuilder.addCase(bucket.getKey(), caseBlock);
}
switchBuilder.defaultCase(jump(defaultLabel));
Binding hashCodeBinding = generatorContext.getCallSiteBinder().bind(hashCodeFunction);
switchBlock = new BytecodeBlock().comment("lookupSwitch(hashCode(<stackValue>))").getVariable(value).append(invoke(hashCodeBinding, HASH_CODE.name())).invokeStatic(Long.class, "hashCode", int.class, long.class).putVariable(expression).append(switchBuilder.build());
break;
case SET_CONTAINS:
Set<?> constantValuesSet = toFastutilHashSet(constantValues, type, functionAndTypeManager);
Binding constant = generatorContext.getCallSiteBinder().bind(constantValuesSet, constantValuesSet.getClass());
switchBlock = new BytecodeBlock().comment("inListSet.contains(<stackValue>)").append(new IfStatement().condition(new BytecodeBlock().comment("value").getVariable(value).comment("set").append(loadConstant(constant)).invokeStatic(FastutilSetHelper.class, "in", boolean.class, javaType.isPrimitive() ? javaType : Object.class, constantValuesSet.getClass())).ifTrue(jump(match)));
break;
default:
throw new IllegalArgumentException("Not supported switch generation case: " + switchGenerationCase);
}
BytecodeBlock defaultCaseBlock = buildInCase(generatorContext, scope, type, match, noMatch, value, defaultBucket.build(), true, isIndeterminateFunction).setDescription("default");
BytecodeBlock block = new BytecodeBlock().comment("IN").append(generatorContext.generate(arguments.get(0), Optional.empty())).append(ifWasNullPopAndGoto(scope, end, boolean.class, javaType)).putVariable(value).append(switchBlock).visitLabel(defaultLabel).append(defaultCaseBlock);
BytecodeBlock matchBlock = new BytecodeBlock().setDescription("match").visitLabel(match).append(generatorContext.wasNull().set(constantFalse())).push(true).gotoLabel(end);
block.append(matchBlock);
BytecodeBlock noMatchBlock = new BytecodeBlock().setDescription("noMatch").visitLabel(noMatch).push(false).gotoLabel(end);
block.append(noMatchBlock);
block.visitLabel(end);
outputBlockVariable.ifPresent(output -> block.append(generateWrite(generatorContext, returnType, output)));
return block;
}
use of com.google.common.collect.ImmutableListMultimap in project buck by facebook.
the class PrebuiltCxxLibraryDescription method createBuildRule.
@Override
public <A extends Arg> BuildRule createBuildRule(TargetGraph targetGraph, final BuildRuleParams params, final BuildRuleResolver ruleResolver, final A args) throws NoSuchBuildTargetException {
// See if we're building a particular "type" of this library, and if so, extract
// it as an enum.
Optional<Map.Entry<Flavor, Type>> type = LIBRARY_TYPE.getFlavorAndValue(params.getBuildTarget());
Optional<Map.Entry<Flavor, CxxPlatform>> platform = cxxPlatforms.getFlavorAndValue(params.getBuildTarget());
Optional<ImmutableMap<BuildTarget, Version>> selectedVersions = targetGraph.get(params.getBuildTarget()).getSelectedVersions();
final Optional<String> versionSubdir = selectedVersions.isPresent() && args.versionedSubDir.isPresent() ? Optional.of(args.versionedSubDir.get().getOnlyMatchingValue(selectedVersions.get())) : Optional.empty();
// pre-existing static lib, which we do here.
if (type.isPresent()) {
Preconditions.checkState(platform.isPresent());
BuildTarget baseTarget = params.getBuildTarget().withoutFlavors(type.get().getKey(), platform.get().getKey());
if (type.get().getValue() == Type.EXPORTED_HEADERS) {
return createExportedHeaderSymlinkTreeBuildRule(params, ruleResolver, platform.get().getValue(), args);
} else if (type.get().getValue() == Type.SHARED) {
return createSharedLibraryBuildRule(params, ruleResolver, platform.get().getValue(), selectedVersions, args);
} else if (type.get().getValue() == Type.SHARED_INTERFACE) {
return createSharedLibraryInterface(baseTarget, params, ruleResolver, platform.get().getValue(), versionSubdir, args);
}
}
if (selectedVersions.isPresent() && args.versionedSubDir.isPresent()) {
ImmutableList<String> versionSubDirs = args.versionedSubDir.orElse(VersionMatchedCollection.<String>of()).getMatchingValues(selectedVersions.get());
if (versionSubDirs.size() != 1) {
throw new HumanReadableException("%s: could not get a single version sub dir: %s, %s, %s", params.getBuildTarget(), args.versionedSubDir, versionSubDirs, selectedVersions);
}
}
// Otherwise, we return the generic placeholder of this library, that dependents can use
// get the real build rules via querying the action graph.
final SourcePathResolver pathResolver = new SourcePathResolver(new SourcePathRuleFinder(ruleResolver));
final boolean headerOnly = args.headerOnly.orElse(false);
final boolean forceStatic = args.forceStatic.orElse(false);
return new PrebuiltCxxLibrary(params) {
private final Map<Pair<Flavor, Linker.LinkableDepType>, NativeLinkableInput> nativeLinkableCache = new HashMap<>();
private final LoadingCache<CxxPreprocessables.CxxPreprocessorInputCacheKey, ImmutableMap<BuildTarget, CxxPreprocessorInput>> transitiveCxxPreprocessorInputCache = CxxPreprocessables.getTransitiveCxxPreprocessorInputCache(this);
private boolean hasHeaders(CxxPlatform cxxPlatform) {
if (!args.exportedHeaders.isEmpty()) {
return true;
}
for (SourceList sourceList : args.exportedPlatformHeaders.getMatchingValues(cxxPlatform.getFlavor().toString())) {
if (!sourceList.isEmpty()) {
return true;
}
}
return false;
}
private ImmutableListMultimap<CxxSource.Type, String> getExportedPreprocessorFlags(CxxPlatform cxxPlatform) {
return CxxFlags.getLanguageFlags(args.exportedPreprocessorFlags, args.exportedPlatformPreprocessorFlags, args.exportedLangPreprocessorFlags, cxxPlatform);
}
@Override
public ImmutableList<String> getExportedLinkerFlags(CxxPlatform cxxPlatform) {
return CxxFlags.getFlagsWithPlatformMacroExpansion(args.exportedLinkerFlags, args.exportedPlatformLinkerFlags, cxxPlatform);
}
private String getSoname(CxxPlatform cxxPlatform) {
return PrebuiltCxxLibraryDescription.getSoname(getBuildTarget(), params.getCellRoots(), ruleResolver, cxxPlatform, args.soname, args.libName);
}
private boolean isPlatformSupported(CxxPlatform cxxPlatform) {
return !args.supportedPlatformsRegex.isPresent() || args.supportedPlatformsRegex.get().matcher(cxxPlatform.getFlavor().toString()).find();
}
/**
* Makes sure all build rules needed to produce the shared library are added to the action
* graph.
*
* @return the {@link SourcePath} representing the actual shared library.
*/
private SourcePath requireSharedLibrary(CxxPlatform cxxPlatform, boolean link) throws NoSuchBuildTargetException {
if (link && args.supportsSharedLibraryInterface && cxxPlatform.getSharedLibraryInterfaceFactory().isPresent()) {
BuildTarget target = params.getBuildTarget().withAppendedFlavors(cxxPlatform.getFlavor(), Type.SHARED_INTERFACE.getFlavor());
BuildRule rule = ruleResolver.requireRule(target);
return Preconditions.checkNotNull(rule.getSourcePathToOutput());
}
return PrebuiltCxxLibraryDescription.this.requireSharedLibrary(params.getBuildTarget(), ruleResolver, pathResolver, params.getCellRoots(), params.getProjectFilesystem(), cxxPlatform, versionSubdir, args);
}
/**
* @return the {@link Optional} containing a {@link SourcePath} representing the actual
* static PIC library.
*/
private Optional<SourcePath> getStaticPicLibrary(CxxPlatform cxxPlatform) {
SourcePath staticPicLibraryPath = PrebuiltCxxLibraryDescription.getStaticPicLibraryPath(getBuildTarget(), params.getCellRoots(), params.getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, args.libDir, args.libName);
if (params.getProjectFilesystem().exists(pathResolver.getAbsolutePath(staticPicLibraryPath))) {
return Optional.of(staticPicLibraryPath);
}
// If a specific static-pic variant isn't available, then just use the static variant.
SourcePath staticLibraryPath = PrebuiltCxxLibraryDescription.getStaticLibraryPath(getBuildTarget(), params.getCellRoots(), getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, args.libDir, args.libName);
if (params.getProjectFilesystem().exists(pathResolver.getAbsolutePath(staticLibraryPath))) {
return Optional.of(staticLibraryPath);
}
return Optional.empty();
}
@Override
public Iterable<? extends CxxPreprocessorDep> getCxxPreprocessorDeps(CxxPlatform cxxPlatform) {
if (!isPlatformSupported(cxxPlatform)) {
return ImmutableList.of();
}
return FluentIterable.from(getDeps()).filter(CxxPreprocessorDep.class);
}
@Override
public CxxPreprocessorInput getCxxPreprocessorInput(final CxxPlatform cxxPlatform, HeaderVisibility headerVisibility) throws NoSuchBuildTargetException {
CxxPreprocessorInput.Builder builder = CxxPreprocessorInput.builder();
switch(headerVisibility) {
case PUBLIC:
if (hasHeaders(cxxPlatform)) {
CxxPreprocessables.addHeaderSymlinkTree(builder, getBuildTarget(), ruleResolver, cxxPlatform, headerVisibility, CxxPreprocessables.IncludeType.SYSTEM);
}
builder.putAllPreprocessorFlags(Preconditions.checkNotNull(getExportedPreprocessorFlags(cxxPlatform)));
builder.addAllFrameworks(args.frameworks);
final Iterable<SourcePath> includePaths = args.includeDirs.stream().map(input -> PrebuiltCxxLibraryDescription.getApplicableSourcePath(params.getBuildTarget(), params.getCellRoots(), params.getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, input, Optional.empty())).collect(MoreCollectors.toImmutableList());
for (SourcePath includePath : includePaths) {
builder.addIncludes(CxxHeadersDir.of(CxxPreprocessables.IncludeType.SYSTEM, includePath));
}
return builder.build();
case PRIVATE:
return builder.build();
}
// want the compiler to warn if someone modifies the HeaderVisibility enum.
throw new RuntimeException("Invalid header visibility: " + headerVisibility);
}
@Override
public Optional<HeaderSymlinkTree> getExportedHeaderSymlinkTree(CxxPlatform cxxPlatform) {
if (hasHeaders(cxxPlatform)) {
return Optional.of(CxxPreprocessables.requireHeaderSymlinkTreeForLibraryTarget(ruleResolver, getBuildTarget(), cxxPlatform.getFlavor()));
} else {
return Optional.empty();
}
}
@Override
public ImmutableMap<BuildTarget, CxxPreprocessorInput> getTransitiveCxxPreprocessorInput(CxxPlatform cxxPlatform, HeaderVisibility headerVisibility) throws NoSuchBuildTargetException {
return transitiveCxxPreprocessorInputCache.getUnchecked(ImmutableCxxPreprocessorInputCacheKey.of(cxxPlatform, headerVisibility));
}
@Override
public Iterable<NativeLinkable> getNativeLinkableDeps() {
return getDeclaredDeps().stream().filter(r -> r instanceof NativeLinkable).map(r -> (NativeLinkable) r).collect(MoreCollectors.toImmutableList());
}
@Override
public Iterable<NativeLinkable> getNativeLinkableDepsForPlatform(CxxPlatform cxxPlatform) {
if (!isPlatformSupported(cxxPlatform)) {
return ImmutableList.of();
}
return getNativeLinkableDeps();
}
@Override
public Iterable<? extends NativeLinkable> getNativeLinkableExportedDeps() {
return args.exportedDeps.stream().map(ruleResolver::getRule).filter(r -> r instanceof NativeLinkable).map(r -> (NativeLinkable) r).collect(MoreCollectors.toImmutableList());
}
@Override
public Iterable<? extends NativeLinkable> getNativeLinkableExportedDepsForPlatform(CxxPlatform cxxPlatform) {
if (!isPlatformSupported(cxxPlatform)) {
return ImmutableList.of();
}
return getNativeLinkableExportedDeps();
}
private NativeLinkableInput getNativeLinkableInputUncached(CxxPlatform cxxPlatform, Linker.LinkableDepType type) throws NoSuchBuildTargetException {
if (!isPlatformSupported(cxxPlatform)) {
return NativeLinkableInput.of();
}
// Build the library path and linker arguments that we pass through the
// {@link NativeLinkable} interface for linking.
ImmutableList.Builder<com.facebook.buck.rules.args.Arg> linkerArgsBuilder = ImmutableList.builder();
linkerArgsBuilder.addAll(StringArg.from(Preconditions.checkNotNull(getExportedLinkerFlags(cxxPlatform))));
if (!headerOnly) {
if (type == Linker.LinkableDepType.SHARED) {
Preconditions.checkState(getPreferredLinkage(cxxPlatform) != Linkage.STATIC);
final SourcePath sharedLibrary = requireSharedLibrary(cxxPlatform, true);
if (args.linkWithoutSoname) {
if (!(sharedLibrary instanceof PathSourcePath)) {
throw new HumanReadableException("%s: can only link prebuilt DSOs without sonames", getBuildTarget());
}
linkerArgsBuilder.add(new RelativeLinkArg((PathSourcePath) sharedLibrary));
} else {
linkerArgsBuilder.add(SourcePathArg.of(requireSharedLibrary(cxxPlatform, true)));
}
} else {
Preconditions.checkState(getPreferredLinkage(cxxPlatform) != Linkage.SHARED);
SourcePath staticLibraryPath = type == Linker.LinkableDepType.STATIC_PIC ? getStaticPicLibrary(cxxPlatform).get() : PrebuiltCxxLibraryDescription.getStaticLibraryPath(getBuildTarget(), params.getCellRoots(), params.getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, args.libDir, args.libName);
SourcePathArg staticLibrary = SourcePathArg.of(staticLibraryPath);
if (args.linkWhole) {
Linker linker = cxxPlatform.getLd().resolve(ruleResolver);
linkerArgsBuilder.addAll(linker.linkWhole(staticLibrary));
} else {
linkerArgsBuilder.add(FileListableLinkerInputArg.withSourcePathArg(staticLibrary));
}
}
}
final ImmutableList<com.facebook.buck.rules.args.Arg> linkerArgs = linkerArgsBuilder.build();
return NativeLinkableInput.of(linkerArgs, args.frameworks, args.libraries);
}
@Override
public NativeLinkableInput getNativeLinkableInput(CxxPlatform cxxPlatform, Linker.LinkableDepType type) throws NoSuchBuildTargetException {
Pair<Flavor, Linker.LinkableDepType> key = new Pair<>(cxxPlatform.getFlavor(), type);
NativeLinkableInput input = nativeLinkableCache.get(key);
if (input == null) {
input = getNativeLinkableInputUncached(cxxPlatform, type);
nativeLinkableCache.put(key, input);
}
return input;
}
@Override
public NativeLinkable.Linkage getPreferredLinkage(CxxPlatform cxxPlatform) {
if (headerOnly) {
return Linkage.ANY;
}
if (forceStatic) {
return Linkage.STATIC;
}
if (args.provided || !getStaticPicLibrary(cxxPlatform).isPresent()) {
return Linkage.SHARED;
}
return Linkage.ANY;
}
@Override
public Iterable<AndroidPackageable> getRequiredPackageables() {
return AndroidPackageableCollector.getPackageableRules(params.getDeps());
}
@Override
public void addToCollector(AndroidPackageableCollector collector) {
if (args.canBeAsset) {
collector.addNativeLinkableAsset(this);
} else {
collector.addNativeLinkable(this);
}
}
@Override
public ImmutableMap<String, SourcePath> getSharedLibraries(CxxPlatform cxxPlatform) throws NoSuchBuildTargetException {
if (!isPlatformSupported(cxxPlatform)) {
return ImmutableMap.of();
}
String resolvedSoname = getSoname(cxxPlatform);
ImmutableMap.Builder<String, SourcePath> solibs = ImmutableMap.builder();
if (!headerOnly && !args.provided) {
SourcePath sharedLibrary = requireSharedLibrary(cxxPlatform, false);
solibs.put(resolvedSoname, sharedLibrary);
}
return solibs.build();
}
@Override
public Optional<NativeLinkTarget> getNativeLinkTarget(CxxPlatform cxxPlatform) {
if (getPreferredLinkage(cxxPlatform) == Linkage.SHARED) {
return Optional.empty();
}
return Optional.of(new NativeLinkTarget() {
@Override
public BuildTarget getBuildTarget() {
return params.getBuildTarget();
}
@Override
public NativeLinkTargetMode getNativeLinkTargetMode(CxxPlatform cxxPlatform) {
return NativeLinkTargetMode.library(getSoname(cxxPlatform));
}
@Override
public Iterable<? extends NativeLinkable> getNativeLinkTargetDeps(CxxPlatform cxxPlatform) {
return Iterables.concat(getNativeLinkableDepsForPlatform(cxxPlatform), getNativeLinkableExportedDepsForPlatform(cxxPlatform));
}
@Override
public NativeLinkableInput getNativeLinkTargetInput(CxxPlatform cxxPlatform) throws NoSuchBuildTargetException {
return NativeLinkableInput.builder().addAllArgs(StringArg.from(getExportedLinkerFlags(cxxPlatform))).addAllArgs(cxxPlatform.getLd().resolve(ruleResolver).linkWhole(SourcePathArg.of(getStaticPicLibrary(cxxPlatform).get()))).build();
}
@Override
public Optional<Path> getNativeLinkTargetOutputPath(CxxPlatform cxxPlatform) {
return Optional.empty();
}
});
}
};
}
use of com.google.common.collect.ImmutableListMultimap in project buck by facebook.
the class Publisher method checkForDuplicatePackagedDeps.
/**
* Checks for any packaged dependencies that exist between more than one of the targets that we
* are trying to publish.
* @return A multimap of dependency build targets and the publishable build targets that have them
* included in the final package that will be uploaded.
*/
private ImmutableListMultimap<UnflavoredBuildTarget, UnflavoredBuildTarget> checkForDuplicatePackagedDeps(ImmutableSet<MavenPublishable> publishables) {
// First build the multimap of the builtin dependencies and the publishable targets that use
// them.
Multimap<UnflavoredBuildTarget, UnflavoredBuildTarget> builtinDeps = HashMultimap.create();
for (MavenPublishable publishable : publishables) {
for (BuildRule buildRule : publishable.getPackagedDependencies()) {
builtinDeps.put(buildRule.getBuildTarget().getUnflavoredBuildTarget(), publishable.getBuildTarget().getUnflavoredBuildTarget());
}
}
// Now, check for any duplicate uses, and if found, return them.
ImmutableListMultimap.Builder<UnflavoredBuildTarget, UnflavoredBuildTarget> builder = ImmutableListMultimap.builder();
for (UnflavoredBuildTarget buildTarget : builtinDeps.keySet()) {
Collection<UnflavoredBuildTarget> publishablesUsingBuildTarget = builtinDeps.get(buildTarget);
if (publishablesUsingBuildTarget.size() > 1) {
builder.putAll(buildTarget, publishablesUsingBuildTarget);
}
}
return builder.build();
}
use of com.google.common.collect.ImmutableListMultimap in project gerrit by GerritCodeReview.
the class ChangeNotes method getApprovals.
public ImmutableListMultimap<PatchSet.Id, PatchSetApproval> getApprovals() {
if (approvals == null) {
ImmutableListMultimap.Builder<PatchSet.Id, PatchSetApproval> b = ImmutableListMultimap.builder();
for (Map.Entry<PatchSet.Id, PatchSetApproval> e : state.approvals()) {
b.put(e.getKey(), new PatchSetApproval(e.getValue()));
}
approvals = b.build();
}
return approvals;
}
use of com.google.common.collect.ImmutableListMultimap in project closure-templates by google.
the class ContextualAutoescaper method findTemplates.
/**
* Fills in the {@link Inferences} template name to node map.
*
* @param files Modified in place.
*/
private static ImmutableListMultimap<String, TemplateNode> findTemplates(Iterable<? extends SoyFileNode> files) {
ImmutableListMultimap.Builder<String, TemplateNode> builder = ImmutableListMultimap.builder();
for (SoyFileNode file : files) {
for (TemplateNode template : file.getChildren()) {
String templateName;
if (template instanceof TemplateBasicNode) {
templateName = template.getTemplateName();
} else {
templateName = ((TemplateDelegateNode) template).getDelTemplateName();
}
builder.put(templateName, template);
}
}
return builder.build();
}
Aggregations