private ImmutableList<TypeToken<? super T>> boundsAsInterfaces(Type[] bounds) { ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder(); for (Type bound : bounds) { @SuppressWarnings("unchecked") // upper bound of T TypeToken<? super T> boundType = (TypeToken<? super T>) of(bound); if (boundType.getRawType().isInterface()) { builder.add(boundType); } } return builder.build(); }
static <E> List<List<E>> create(List<? extends List<? extends E>> lists) { ImmutableList.Builder<List<E>> axesBuilder = new ImmutableList.Builder<>(lists.size()); for (List<? extends E> list : lists) { List<E> copy = ImmutableList.copyOf(list); if (copy.isEmpty()) { return ImmutableList.of(); } axesBuilder.add(copy); } return new CartesianList<E>(axesBuilder.build()); }
/** * Returns an immutable list containing the given elements, in order. * * @throws NullPointerException if any of {@code elements} is null */ public static <E> ImmutableList<E> copyOf(Iterator<? extends E> elements) { // We special-case for 0 or 1 elements, but going further is madness. if (!elements.hasNext()) { return of(); } E first = elements.next(); if (!elements.hasNext()) { return of(first); } else { return new ImmutableList.Builder<E>().add(first).addAll(elements).build(); } }
private List<MongoCredential> buildCredentials(Iterable<String> userPasses) { ImmutableList.Builder<MongoCredential> builder = ImmutableList.builder(); for (String userPass : userPasses) { List<String> values = USER_SPLITTER.splitToList(userPass); checkArgument(values.size() == 3, "Invalid Credential format. Requires user:password@collection"); builder.add(createCredential(values.get(0), values.get(2), values.get(1).toCharArray())); } return builder.build(); }
private static List<ColumnStatistics> toFileStats(List<List<ColumnStatistics>> stripes) { if (stripes.isEmpty()) { return ImmutableList.of(); } int columnCount = stripes.get(0).size(); checkArgument(stripes.stream().allMatch(stripe -> columnCount == stripe.size())); ImmutableList.Builder<ColumnStatistics> fileStats = ImmutableList.builder(); for (int i = 0; i < columnCount; i++) { int column = i; fileStats.add(ColumnStatistics.mergeColumnStatistics(stripes.stream() .map(stripe -> stripe.get(column)) .collect(toList()))); } return fileStats.build(); }
/** * Returns an {@code ImmutableRangeMap} containing the associations previously added to this * builder. * * @throws IllegalArgumentException if any two ranges inserted into this builder overlap */ public ImmutableRangeMap<K, V> build() { Collections.sort(entries, Range.<K>rangeLexOrdering().onKeys()); ImmutableList.Builder<Range<K>> rangesBuilder = new ImmutableList.Builder<>(entries.size()); ImmutableList.Builder<V> valuesBuilder = new ImmutableList.Builder<V>(entries.size()); for (int i = 0; i < entries.size(); i++) { Range<K> range = entries.get(i).getKey(); if (i > 0) { Range<K> prevRange = entries.get(i - 1).getKey(); if (range.isConnected(prevRange) && !range.intersection(prevRange).isEmpty()) { throw new IllegalArgumentException( "Overlapping ranges: range " + prevRange + " overlaps with entry " + range); } } rangesBuilder.add(range); valuesBuilder.add(entries.get(i).getValue()); } return new ImmutableRangeMap<>(rangesBuilder.build(), valuesBuilder.build()); } }
@Test public void testQueryRewriteException() { config.setControlGateway(URL); Query invalidQuery = new Query( CATALOG, SCHEMA, ImmutableList.of("INSERT INTO test_table (a, b, c) values (10, 10.11, 'k')"), "INSERT INTO test_table (a, b, c) values (11, 11.12, 'l')", ImmutableList.of(), null, null, ImmutableMap.of()); List<QueryPair> rewrittenQueries = rewriteQueries(parser, config, ImmutableList.<QueryPair>builder() .addAll(queryPairs) .add(new QueryPair(QUERY_SUITE, QUERY_NAME, invalidQuery, invalidQuery)) .build()); assertEquals(rewrittenQueries.size(), queryPairs.size()); }
public FieldSetFilteringRecordSet(FunctionRegistry functionRegistry, RecordSet delegate, List<Set<Integer>> fieldSets) { requireNonNull(functionRegistry, "functionRegistry is null"); this.delegate = requireNonNull(delegate, "delegate is null"); ImmutableList.Builder<Set<Field>> fieldSetsBuilder = ImmutableList.builder(); List<Type> columnTypes = delegate.getColumnTypes(); for (Set<Integer> fieldSet : requireNonNull(fieldSets, "fieldSets is null")) { ImmutableSet.Builder<Field> fieldSetBuilder = ImmutableSet.builder(); for (int field : fieldSet) { fieldSetBuilder.add(new Field( field, functionRegistry.getScalarFunctionImplementation(internalOperator(OperatorType.EQUAL, BooleanType.BOOLEAN, ImmutableList.of(columnTypes.get(field), columnTypes.get(field)))).getMethodHandle())); } fieldSetsBuilder.add(fieldSetBuilder.build()); } this.fieldSets = fieldSetsBuilder.build(); }
public List<BenchmarkSchema> selectSchemas(Iterable<String> schemas) { if (schemaNameTemplates.isEmpty()) { return ImmutableList.of(); } ImmutableList.Builder<BenchmarkSchema> benchmarkSchemas = ImmutableList.builder(); for (RegexTemplate schemaNameTemplate : schemaNameTemplates) { for (String schema : schemas) { Optional<Map<String, String>> tags = schemaNameTemplate.parse(schema); if (tags.isPresent()) { benchmarkSchemas.add(new BenchmarkSchema(schema, tags.get())); } } } return benchmarkSchemas.build(); }
@GwtIncompatible public void testBuilderExactlySizedReusesArray() { ImmutableList.Builder<Integer> builder = ImmutableList.builderWithExpectedSize(10); Object[] builderArray = builder.contents; for (int i = 0; i < 10; i++) { builder.add(i); } Object[] builderArrayAfterAdds = builder.contents; RegularImmutableList<Integer> list = (RegularImmutableList<Integer>) builder.build(); Object[] listInternalArray = list.array; assertSame(builderArray, builderArrayAfterAdds); assertSame(builderArray, listInternalArray); }
@SuppressWarnings("unchecked") public static <K extends Comparable<?>, V> ImmutableRangeMap<K, V> copyOf( RangeMap<K, ? extends V> rangeMap) { if (rangeMap instanceof ImmutableRangeMap) { return (ImmutableRangeMap<K, V>) rangeMap; } Map<Range<K>, ? extends V> map = rangeMap.asMapOfRanges(); ImmutableList.Builder<Range<K>> rangesBuilder = new ImmutableList.Builder<>(map.size()); ImmutableList.Builder<V> valuesBuilder = new ImmutableList.Builder<V>(map.size()); for (Entry<Range<K>, ? extends V> entry : map.entrySet()) { rangesBuilder.add(entry.getKey()); valuesBuilder.add(entry.getValue()); } return new ImmutableRangeMap<>(rangesBuilder.build(), valuesBuilder.build()); }
private static List<IndexJoinNode.EquiJoinClause> createEquiJoinClause(List<Symbol> probeSymbols, List<Symbol> indexSymbols) { checkArgument(probeSymbols.size() == indexSymbols.size()); ImmutableList.Builder<IndexJoinNode.EquiJoinClause> builder = ImmutableList.builder(); for (int i = 0; i < probeSymbols.size(); i++) { builder.add(new IndexJoinNode.EquiJoinClause(probeSymbols.get(i), indexSymbols.get(i))); } return builder.build(); } }
private static List<HivePartitionKey> getPartitionKeys(Table table, Optional<Partition> partition) { if (!partition.isPresent()) { return ImmutableList.of(); } ImmutableList.Builder<HivePartitionKey> partitionKeys = ImmutableList.builder(); List<Column> keys = table.getPartitionColumns(); List<String> values = partition.get().getValues(); checkCondition(keys.size() == values.size(), HIVE_INVALID_METADATA, "Expected %s partition key values, but got %s", keys.size(), values.size()); for (int i = 0; i < keys.size(); i++) { String name = keys.get(i).getName(); HiveType hiveType = keys.get(i).getType(); if (!hiveType.isSupportedType()) { throw new PrestoException(NOT_SUPPORTED, format("Unsupported Hive type %s found in partition keys of table %s.%s", hiveType, table.getDatabaseName(), table.getTableName())); } String value = values.get(i); checkCondition(value != null, HIVE_INVALID_PARTITION_VALUE, "partition key value cannot be null for field: %s", name); partitionKeys.add(new HivePartitionKey(name, value)); } return partitionKeys.build(); }
private static List<Type> toTypes(List<? extends Type> sourceTypes, List<Integer> outputChannels, boolean generateRowNumber) { ImmutableList.Builder<Type> types = ImmutableList.builder(); for (int channel : outputChannels) { types.add(sourceTypes.get(channel)); } if (generateRowNumber) { types.add(BIGINT); } return types.build(); } }
private static List<Integer> getHashChannels(RowPagesBuilder probe, RowPagesBuilder build) { ImmutableList.Builder<Integer> hashChannels = ImmutableList.builder(); if (probe.getHashChannel().isPresent()) { hashChannels.add(probe.getHashChannel().get()); } if (build.getHashChannel().isPresent()) { hashChannels.add(probe.getTypes().size() + build.getHashChannel().get()); } return hashChannels.build(); }
static <E> List<List<E>> create(List<? extends List<? extends E>> lists) { ImmutableList.Builder<List<E>> axesBuilder = new ImmutableList.Builder<>(lists.size()); for (List<? extends E> list : lists) { List<E> copy = ImmutableList.copyOf(list); if (copy.isEmpty()) { return ImmutableList.of(); } axesBuilder.add(copy); } return new CartesianList<E>(axesBuilder.build()); }