@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 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; }
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 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; }