@Override
public PlanNode visitUnion(UnionNode node, RewriteContext<Set<Symbol>> context) {
// Find out which output symbols we need to keep
ImmutableListMultimap.Builder<Symbol, Symbol> rewrittenSymbolMappingBuilder =
ImmutableListMultimap.builder();
for (Symbol symbol : node.getOutputSymbols()) {
if (context.get().contains(symbol)) {
rewrittenSymbolMappingBuilder.putAll(symbol, node.getSymbolMapping().get(symbol));
}
}
ListMultimap<Symbol, Symbol> rewrittenSymbolMapping = rewrittenSymbolMappingBuilder.build();
// Find the corresponding input symbol to the remaining output symbols and prune the subplans
ImmutableList.Builder<PlanNode> rewrittenSubPlans = ImmutableList.builder();
for (int i = 0; i < node.getSources().size(); i++) {
ImmutableSet.Builder<Symbol> expectedInputSymbols = ImmutableSet.builder();
for (Collection<Symbol> symbols : rewrittenSymbolMapping.asMap().values()) {
expectedInputSymbols.add(Iterables.get(symbols, i));
}
rewrittenSubPlans.add(
context.rewrite(node.getSources().get(i), expectedInputSymbols.build()));
}
return new UnionNode(
node.getId(),
rewrittenSubPlans.build(),
rewrittenSymbolMapping,
ImmutableList.copyOf(rewrittenSymbolMapping.keySet()));
}
public Multimap<String, String> headers() {
ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
for (Header header : httpResponse.getAllHeaders()) {
builder.put(header.getName(), header.getValue());
}
return builder.build();
}
public static <K, V> ImmutableListMultimap<K, V> groupBy(
Iterable<? extends V> iterable, Transformer<? extends K, V> grouper) {
ImmutableListMultimap.Builder<K, V> builder = ImmutableListMultimap.builder();
for (V element : iterable) {
K key = grouper.transform(element);
builder.put(key, element);
}
return builder.build();
}
public RuleNames(Grammar grammar, boolean installAdapter) {
this.contextGrammar = grammar;
Adapter adapter = new Adapter(this);
if (installAdapter) {
installAdapterIfMissing(adapter, grammar);
}
List<AbstractRule> allRules = GrammarUtil.allRules(grammar);
ImmutableListMultimap.Builder<String, AbstractRule> simpleNameToRulesBuilder =
ImmutableListMultimap.builder();
ImmutableMap.Builder<String, AbstractRule> qualifiedNameToRuleBuilder = ImmutableMap.builder();
ImmutableBiMap.Builder<String, AbstractRule> uniqueNameToRuleBuilder = ImmutableBiMap.builder();
ImmutableBiMap.Builder<String, AbstractRule> antlrNameToRuleBuilder = ImmutableBiMap.builder();
Map<String, AbstractRule> names = Maps.newHashMap();
Set<String> usedAntlrNames = Sets.newHashSet();
Set<String> usedUniqueNames = Sets.newHashSet();
for (AbstractRule rule : allRules) {
String name = rule.getName();
simpleNameToRulesBuilder.put(name, rule);
String qualifiedName = getQualifiedName(rule);
qualifiedNameToRuleBuilder.put(qualifiedName, rule);
String uniqueName = name;
String antlrRuleName;
if (names.containsKey(name)) {
name = qualifiedName;
uniqueName = getInheritedUniqueName(rule, usedUniqueNames);
antlrRuleName = getInheritedAntlrRuleName(rule, usedAntlrNames);
} else {
antlrRuleName = getDefaultAntlrRuleName(rule);
}
names.put(name, rule);
if (!usedUniqueNames.add(uniqueName)) {
throw new IllegalStateException(uniqueName);
}
uniqueNameToRuleBuilder.put(uniqueName, rule);
if (!usedAntlrNames.add(antlrRuleName)) {
throw new IllegalStateException(antlrRuleName);
}
antlrNameToRuleBuilder.put(antlrRuleName, rule);
if (installAdapter) {
installAdapterIfMissing(adapter, rule);
}
}
simpleNameToRules = simpleNameToRulesBuilder.build();
qualifiedNameToRule = qualifiedNameToRuleBuilder.build();
nameToRule = ImmutableBiMap.copyOf(names);
uniqueNameToRule = uniqueNameToRuleBuilder.build();
antlrNameToRule = antlrNameToRuleBuilder.build();
this.allRules = ImmutableList.copyOf(allRules);
}
private LinkedResources(Iterable<LinkedResource> resources) {
ImmutableList.Builder<LinkedResource> listBuilder = ImmutableList.builder();
ImmutableListMultimap.Builder<String, LinkedResource> byPathBuilder =
ImmutableListMultimap.builder();
Map<String, LinkedResource> byIdMap = Maps.newHashMap();
for (LinkedResource resource : resources) {
listBuilder.add(resource);
byPathBuilder.put(resource.getPath(), resource);
if (resource.getId().isPresent()) byIdMap.put(resource.getId().get(), resource);
}
this.resources = listBuilder.build();
this.resourcesByPath = byPathBuilder.build();
this.resourcesById = ImmutableMap.copyOf(byIdMap);
}
public MediaType withParameter(String attribute, String value) {
Preconditions.checkNotNull(attribute);
Preconditions.checkNotNull(value);
String normalizedAttribute = normalizeToken(attribute);
ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
for (Map.Entry<String, String> entry : this.parameters.entries()) {
String key = (String) entry.getKey();
if (!normalizedAttribute.equals(key)) {
builder.put(key, entry.getValue());
}
}
builder.put(normalizedAttribute, normalizeParameterValue(normalizedAttribute, value));
MediaType mediaType = new MediaType(this.type, this.subtype, builder.build());
return (MediaType) Objects.firstNonNull(KNOWN_TYPES.get(mediaType), mediaType);
}
// Here are the details of the matching. We track the current brace depth, and we artificially
// consider that the whole file is at brace depth 1 inside a pseudo-class whose name is the
// name of the package. When we see a class definition, we push the fully-qualified name of the
// class on a stack so that we can associate abstract methods we find with the possibly-nested
// class they belong to. A class definition must occur at brace depth one more than the class
// containing it, which is equivalent to saying that the brace depth must be the same as the
// class stack depth. This check excludes local class definitions within methods and
// initializers. If we meet these constraints and we see the word "class" followed by an
// identifier Foo, then we consider that we are entering the definition of class Foo. We determine
// the fully-qualified name of Foo, which is container.Foo, where container is the current top of
// the class stack (initially, the package name). We push this new fully-qualified name on the
// class stack. We have not yet seen the left brace with the class definition so at this point the
// class stack depth is one more than the brace depth. When we subsequently see a right brace that
// takes us back to this situation then we know we have completed the definition of Foo and we can
// pop it from the class stack.
//
// We check that the token after "class" is indeed an identifier to avoid confusion
// with Foo.class. Even though the tokenizer does not distinguish between identifiers and
// keywords, it is enough to exclude the single word "instanceof" because that is the only word
// that can legally appear after Foo.class (though in a legal program the resultant expression
// will always be true).
//
// Again, we are at the top level of a class when the brace depth is equal to the class stack
// depth. If we then see the word "abstract" then that is the start either of an abstract class
// definition or of an abstract method. We record that we have seen "abstract" and we cancel
// that indication as soon as we see a left brace, to exclude the abstract class case, and also
// the case of interfaces or @interfaces redundantly declared abstract. Now, when
// we see an identifier that is preceded by an uncanceled "abstract" and followed by a left paren
// then we have found an abstract method of the class on the top of the class stack. We record it
// in the list of abstract methods of the class on the top of the class stack. We don't bother
// checking that the method has no parameters, because an @AutoCursor class will cause a compiler
// error if there are abstract methods with parameters, since the @AutoCursor processor doesn't
// know how to implement them in the concrete subclass it generates.
ImmutableListMultimap<String, String> abstractMethods(
JavaTokenizer tokenizer, String packageName) {
ImmutableListMultimap.Builder<String, String> abstractMethods = ImmutableListMultimap.builder();
Deque<String> classStack = new ArrayDeque<String>();
classStack.addLast(packageName);
int braceDepth = 1;
boolean sawAbstract = false;
String className = null;
for (String previousToken = "", token = tokenizer.nextToken();
token != null;
previousToken = token, token = tokenizer.nextToken()) {
boolean topLevel = (braceDepth == classStack.size());
if (className != null) {
if (Character.isJavaIdentifierStart(className.charAt(0))
&& !className.equals("instanceof")) {
String container = classStack.getLast();
// container might be empty in the case of a packageless class
classStack.add(container.isEmpty() ? className : container + "." + className);
}
className = null;
}
if (token.equals("{")) {
braceDepth++;
sawAbstract = false;
} else if (token.equals("}")) {
braceDepth--;
if (topLevel) {
classStack.removeLast();
}
} else if (topLevel) {
if (token.equals("class") || token.equals("interface")) {
className = tokenizer.nextToken();
} else if (token.equals("abstract")) {
sawAbstract = true;
} else if (token.equals("(")) {
if (sawAbstract && Character.isJavaIdentifierStart(previousToken.charAt(0))) {
abstractMethods.put(classStack.getLast(), previousToken);
}
sawAbstract = false;
}
}
}
return abstractMethods.build();
}
public static void dumpRegistry(File minecraftDir) {
if (customItemStacks == null) {
return;
}
if (Boolean.valueOf(System.getProperty("fml.dumpRegistry", "false")).booleanValue()) {
ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
for (String modId : customItemStacks.rowKeySet()) {
builder.putAll(modId, customItemStacks.row(modId).keySet());
}
File f = new File(minecraftDir, "itemStackRegistry.csv");
MapJoiner mapJoiner = Joiner.on("\n").withKeyValueSeparator(",");
try {
Files.write(mapJoiner.join(builder.build().entries()), f, Charsets.UTF_8);
FMLLog.log(Level.INFO, "Dumped item registry data to %s", f.getAbsolutePath());
} catch (IOException e) {
FMLLog.log(Level.ERROR, e, "Failed to write registry data to %s", f.getAbsolutePath());
}
}
}
private static MediaType create(
String type, String subtype, Multimap<String, String> parameters) {
Preconditions.checkNotNull(type);
Preconditions.checkNotNull(subtype);
Preconditions.checkNotNull(parameters);
String normalizedType = normalizeToken(type);
String normalizedSubtype = normalizeToken(subtype);
Preconditions.checkArgument(
(!"*".equals(normalizedType)) || ("*".equals(normalizedSubtype)),
"A wildcard type cannot be used with a non-wildcard subtype");
ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
for (Map.Entry<String, String> entry : parameters.entries()) {
String attribute = normalizeToken((String) entry.getKey());
builder.put(attribute, normalizeParameterValue(attribute, (String) entry.getValue()));
}
MediaType mediaType = new MediaType(normalizedType, normalizedSubtype, builder.build());
return (MediaType) Objects.firstNonNull(KNOWN_TYPES.get(mediaType), mediaType);
}
public Builder concatenate(Term term) {
if (term instanceof CellCollection) {
CellCollection cellCollection = (CellCollection) term;
cellsBuilder.putAll(cellCollection.cells);
collectionVariablesBuilder.addAll(cellCollection.collectionVariables);
} else if (term instanceof Variable && term.kind == Kind.CELL_COLLECTION) {
collectionVariablesBuilder.add((Variable) term);
} else {
assert false : "unexpected concatenated term " + term;
}
return this;
}
@Override
public void apply(JsonArray value, Config.Builder builder) {
ImmutableListMultimap.Builder<CustomPassExecutionTime, CompilerPassFactory> customPasses =
ImmutableListMultimap.builder();
Gson gson =
new GsonBuilder()
.registerTypeAdapter(
CustomPassConfig.class, new CustomPassConfig.CustomPassConfigDeserializer())
.create();
for (JsonElement entry : value) {
CustomPassConfig pass = gson.fromJson(entry, CustomPassConfig.class);
Class<?> clazz;
try {
clazz = Class.forName(pass.getClassName());
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
CompilerPassFactory factory = new CompilerPassFactory(clazz);
customPasses.put(pass.getWhen(), factory);
}
builder.setCustomPasses(customPasses.build());
}
public Term build() {
ImmutableListMultimap<CellLabel, Cell> cells = cellsBuilder.build();
ImmutableMultiset<Variable> collectionVariables = collectionVariablesBuilder.build();
if (cells.isEmpty()) {
switch (collectionVariables.size()) {
case 1:
return collectionVariables.iterator().next();
default:
return new CellCollection(cells, collectionVariables, cellSort, definition);
}
} else {
return new CellCollection(cells, collectionVariables, cellSort, definition);
}
}
public static MediaType parse(String input) {
Preconditions.checkNotNull(input);
Tokenizer tokenizer = new Tokenizer(input);
try {
String type = tokenizer.consumeToken(TOKEN_MATCHER);
tokenizer.consumeCharacter('/');
String subtype = tokenizer.consumeToken(TOKEN_MATCHER);
ImmutableListMultimap.Builder<String, String> parameters = ImmutableListMultimap.builder();
while (tokenizer.hasMore()) {
tokenizer.consumeCharacter(';');
tokenizer.consumeTokenIfPresent(LINEAR_WHITE_SPACE);
String attribute = tokenizer.consumeToken(TOKEN_MATCHER);
tokenizer.consumeCharacter('=');
String value;
if ('"' == tokenizer.previewChar()) {
tokenizer.consumeCharacter('"');
StringBuilder valueBuilder = new StringBuilder();
while ('"' != tokenizer.previewChar()) {
if ('\\' == tokenizer.previewChar()) {
tokenizer.consumeCharacter('\\');
valueBuilder.append(tokenizer.consumeCharacter(CharMatcher.ASCII));
} else {
valueBuilder.append(tokenizer.consumeToken(QUOTED_TEXT_MATCHER));
}
}
String value = valueBuilder.toString();
tokenizer.consumeCharacter('"');
} else {
value = tokenizer.consumeToken(TOKEN_MATCHER);
}
parameters.put(attribute, value);
}
return create(type, subtype, parameters.build());
} catch (IllegalStateException e) {
throw new IllegalArgumentException("Could not parse '" + input + "'", e);
}
}
public Builder add(Cell cell) {
cellsBuilder.put(cell.cellLabel(), cell);
return this;
}
private void doProcess(RoundEnvironment roundEnv) {
for (Element element : roundEnv.getElementsAnnotatedWith(Provided.class)) {
providedChecker.checkProvidedParameter(element);
}
ImmutableListMultimap.Builder<String, FactoryMethodDescriptor> indexedMethods =
ImmutableListMultimap.builder();
ImmutableSet.Builder<ImplementationMethodDescriptor> implementationMethodDescriptors =
ImmutableSet.builder();
for (Element element : roundEnv.getElementsAnnotatedWith(AutoFactory.class)) {
Optional<AutoFactoryDeclaration> declaration = declarationFactory.createIfValid(element);
if (declaration.isPresent()) {
TypeElement extendingType = declaration.get().extendingType();
List<ExecutableElement> supertypeMethods =
ElementFilter.methodsIn(elements.getAllMembers(extendingType));
for (ExecutableElement supertypeMethod : supertypeMethods) {
if (supertypeMethod.getModifiers().contains(Modifier.ABSTRACT)) {
ExecutableType methodType =
Elements2.getExecutableElementAsMemberOf(types, supertypeMethod, extendingType);
implementationMethodDescriptors.add(
new ImplementationMethodDescriptor.Builder()
.name(supertypeMethod.getSimpleName().toString())
.returnType(getAnnotatedType(element).getQualifiedName().toString())
.publicMethod()
.passedParameters(
Parameter.forParameterList(
supertypeMethod.getParameters(), methodType.getParameterTypes()))
.build());
}
}
for (TypeElement implementingType : declaration.get().implementingTypes()) {
List<ExecutableElement> interfaceMethods =
ElementFilter.methodsIn(elements.getAllMembers(implementingType));
for (ExecutableElement interfaceMethod : interfaceMethods) {
if (interfaceMethod.getModifiers().contains(Modifier.ABSTRACT)) {
ExecutableType methodType =
Elements2.getExecutableElementAsMemberOf(
types, interfaceMethod, implementingType);
implementationMethodDescriptors.add(
new ImplementationMethodDescriptor.Builder()
.name(interfaceMethod.getSimpleName().toString())
.returnType(getAnnotatedType(element).getQualifiedName().toString())
.publicMethod()
.passedParameters(
Parameter.forParameterList(
interfaceMethod.getParameters(), methodType.getParameterTypes()))
.build());
}
}
}
}
ImmutableSet<FactoryMethodDescriptor> descriptors =
factoryDescriptorGenerator.generateDescriptor(element);
indexedMethods.putAll(
Multimaps.index(
descriptors,
new Function<FactoryMethodDescriptor, String>() {
@Override
public String apply(FactoryMethodDescriptor descriptor) {
return descriptor.factoryName();
}
}));
}
for (Entry<String, Collection<FactoryMethodDescriptor>> entry :
indexedMethods.build().asMap().entrySet()) {
ImmutableSet.Builder<String> extending = ImmutableSet.builder();
ImmutableSortedSet.Builder<String> implementing = ImmutableSortedSet.naturalOrder();
boolean publicType = false;
Boolean allowSubclasses = null;
boolean skipCreation = false;
for (FactoryMethodDescriptor methodDescriptor : entry.getValue()) {
extending.add(methodDescriptor.declaration().extendingType().getQualifiedName().toString());
for (TypeElement implementingType : methodDescriptor.declaration().implementingTypes()) {
implementing.add(implementingType.getQualifiedName().toString());
}
publicType |= methodDescriptor.publicMethod();
if (allowSubclasses == null) {
allowSubclasses = methodDescriptor.declaration().allowSubclasses();
} else if (!allowSubclasses.equals(methodDescriptor.declaration().allowSubclasses())) {
skipCreation = true;
messager.printMessage(
Kind.ERROR,
"Cannot mix allowSubclasses=true and allowSubclasses=false in one factory.",
methodDescriptor.declaration().target(),
methodDescriptor.declaration().mirror(),
methodDescriptor.declaration().valuesMap().get("allowSubclasses"));
}
}
if (!skipCreation) {
try {
factoryWriter.writeFactory(
new FactoryDescriptor(
entry.getKey(),
Iterables.getOnlyElement(extending.build()),
implementing.build(),
publicType,
ImmutableSet.copyOf(entry.getValue()),
// TODO(gak): this needs to be indexed too
implementationMethodDescriptors.build(),
allowSubclasses));
} catch (IOException e) {
messager.printMessage(Kind.ERROR, "failed");
}
}
}
}
public Builder putAll(ListMultimap<CellLabel, Cell> cellMap) {
cellsBuilder.putAll(cellMap);
return this;
}
public Builder put(CellLabel cellLabel, Term content) {
cellsBuilder.put(cellLabel, new Cell(cellLabel, content));
return this;
}
@Override
protected RelationPlan visitUnion(Union node, Void context) {
checkArgument(!node.getRelations().isEmpty(), "No relations specified for UNION");
List<Symbol> unionOutputSymbols = null;
ImmutableList.Builder<PlanNode> sources = ImmutableList.builder();
ImmutableListMultimap.Builder<Symbol, Symbol> symbolMapping = ImmutableListMultimap.builder();
List<RelationPlan> subPlans =
node.getRelations()
.stream()
.map(relation -> processAndCoerceIfNecessary(relation, context))
.collect(toImmutableList());
boolean hasSampleWeight = false;
for (RelationPlan subPlan : subPlans) {
if (subPlan.getSampleWeight().isPresent()) {
hasSampleWeight = true;
break;
}
}
Optional<Symbol> outputSampleWeight = Optional.empty();
for (RelationPlan relationPlan : subPlans) {
if (hasSampleWeight && !relationPlan.getSampleWeight().isPresent()) {
relationPlan = addConstantSampleWeight(relationPlan);
}
List<Symbol> childOutputSymbols = relationPlan.getOutputSymbols();
if (unionOutputSymbols == null) {
// Use the first Relation to derive output symbol names
TupleDescriptor descriptor = relationPlan.getDescriptor();
ImmutableList.Builder<Symbol> outputSymbolBuilder = ImmutableList.builder();
for (Field field : descriptor.getVisibleFields()) {
int fieldIndex = descriptor.indexOf(field);
Symbol symbol = childOutputSymbols.get(fieldIndex);
outputSymbolBuilder.add(
symbolAllocator.newSymbol(symbol.getName(), symbolAllocator.getTypes().get(symbol)));
}
unionOutputSymbols = outputSymbolBuilder.build();
outputSampleWeight = relationPlan.getSampleWeight();
}
TupleDescriptor descriptor = relationPlan.getDescriptor();
checkArgument(
descriptor.getVisibleFieldCount() == unionOutputSymbols.size(),
"Expected relation to have %s symbols but has %s symbols",
descriptor.getVisibleFieldCount(),
unionOutputSymbols.size());
int unionFieldId = 0;
for (Field field : descriptor.getVisibleFields()) {
int fieldIndex = descriptor.indexOf(field);
symbolMapping.put(unionOutputSymbols.get(unionFieldId), childOutputSymbols.get(fieldIndex));
unionFieldId++;
}
sources.add(relationPlan.getRoot());
}
PlanNode planNode =
new UnionNode(idAllocator.getNextId(), sources.build(), symbolMapping.build());
if (node.isDistinct()) {
planNode = distinct(planNode);
}
return new RelationPlan(
planNode,
analysis.getOutputDescriptor(node),
planNode.getOutputSymbols(),
outputSampleWeight);
}