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); }
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); }
// 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(); }
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); }
@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 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 put(CellLabel cellLabel, Term content) { cellsBuilder.put(cellLabel, new Cell(cellLabel, content)); return this; }
public Builder add(Cell cell) { cellsBuilder.put(cell.cellLabel(), cell); 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); }