/** * Returns a new builder. The generated builder is equivalent to the builder created by the {@link * Builder} constructor. */ public static <E> Builder<E> builder() { return new Builder<E>(); }
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(); } }
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()); }
static <E> Set<List<E>> create(List<? extends Set<? extends E>> sets) { ImmutableList.Builder<ImmutableSet<E>> axesBuilder = new ImmutableList.Builder<>(sets.size()); for (Set<? extends E> set : sets) { ImmutableSet<E> copy = ImmutableSet.copyOf(set); if (copy.isEmpty()) { return ImmutableSet.of(); } axesBuilder.add(copy); } final ImmutableList<ImmutableSet<E>> axes = axesBuilder.build(); ImmutableList<List<E>> listAxes = new ImmutableList<List<E>>() { @Override public int size() { return axes.size(); } @Override public List<E> get(int index) { return axes.get(index).asList(); } @Override boolean isPartialView() { return true; } }; return new CartesianSet<E>(axes, new CartesianList<E>(listAxes)); }
/** * 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()); } }
@GET public List<BasicQueryInfo> getAllQueryInfo(@QueryParam("state") String stateFilter) { QueryState expectedState = stateFilter == null ? null : QueryState.valueOf(stateFilter.toUpperCase(Locale.ENGLISH)); ImmutableList.Builder<BasicQueryInfo> builder = new ImmutableList.Builder<>(); for (BasicQueryInfo queryInfo : queryManager.getQueries()) { if (stateFilter == null || queryInfo.getState() == expectedState) { builder.add(queryInfo); } } return builder.build(); }
private void testCustomAggregation(Long[] values, int n) { PriorityQueue<Long> heap = new PriorityQueue<>(n); Arrays.stream(values).filter(x -> x != null).forEach(heap::add); ImmutableList.Builder<List<Long>> expected = new ImmutableList.Builder<>(); for (int i = heap.size() - 1; i >= 0; i--) { expected.add(ImmutableList.of(heap.remove())); } testAggregation(Lists.reverse(expected.build()), createLongArraysBlock(values), createLongRepeatBlock(n, values.length)); } }
private static List<MemoryPool> getMemoryPools(LocalMemoryManager localMemoryManager) { requireNonNull(localMemoryManager, "localMemoryManager can not be null"); ImmutableList.Builder<MemoryPool> builder = new ImmutableList.Builder<>(); builder.add(localMemoryManager.getGeneralPool()); localMemoryManager.getReservedPool().ifPresent(builder::add); return builder.build(); }
private List<Column> getColumnsForTable(Connection connection, String catalog, String schema, String table) throws SQLException { ResultSet columns = connection.getMetaData().getColumns(catalog, escapeLikeExpression(connection, schema), escapeLikeExpression(connection, table), null); ImmutableList.Builder<Column> columnBuilder = new ImmutableList.Builder<>(); while (columns.next()) { String name = columns.getString("COLUMN_NAME"); int type = columns.getInt("DATA_TYPE"); columnBuilder.add(new Column(name, APPROXIMATE_TYPES.contains(type))); } return columnBuilder.build(); }
private static List<Type> getTypes() { List<Type> simpleTypes = METADATA.getTypeManager().getTypes(); return new ImmutableList.Builder<Type>() .addAll(simpleTypes) .add(VARCHAR) .add(DecimalType.createDecimalType(1)) .add(RowType.anonymous(ImmutableList.of(BIGINT, VARCHAR, DOUBLE))) .build(); }
ResultIterator() { if (produceRowNumber) { pageBuilder = new PageBuilder(new ImmutableList.Builder<Type>().addAll(sourceTypes).add(BIGINT).build()); } else { pageBuilder = new PageBuilder(sourceTypes); } }
private static <E> ImmutableSortedMultiset<E> copyOfSortedEntries( Comparator<? super E> comparator, Collection<Entry<E>> entries) { if (entries.isEmpty()) { return emptyMultiset(comparator); } ImmutableList.Builder<E> elementsBuilder = new ImmutableList.Builder<E>(entries.size()); long[] cumulativeCounts = new long[entries.size() + 1]; int i = 0; for (Entry<E> entry : entries) { elementsBuilder.add(entry.getElement()); cumulativeCounts[i + 1] = cumulativeCounts[i] + entry.getCount(); i++; } return new RegularImmutableSortedMultiset<E>( new RegularImmutableSortedSet<E>(elementsBuilder.build(), comparator), cumulativeCounts, 0, entries.size()); }
/** * Returns a new builder, expecting the specified number of elements to be added. * * <p>If {@code expectedSize} is exactly the number of elements added to the builder before {@link * Builder#build} is called, the builder is likely to perform better than an unsized {@link * #builder()} would have. * * <p>It is not specified if any performance benefits apply if {@code expectedSize} is close to, * but not exactly, the number of elements added to the builder. * * @since 23.1 */ @Beta public static <E> Builder<E> builderWithExpectedSize(int expectedSize) { checkNonnegative(expectedSize, "expectedSize"); return new ImmutableList.Builder<E>(expectedSize); }
Object readResolve() { if (cellValues.length == 0) { return of(); } if (cellValues.length == 1) { return of(rowKeys[0], columnKeys[0], cellValues[0]); } ImmutableList.Builder<Cell<Object, Object, Object>> cellListBuilder = new ImmutableList.Builder<>(cellValues.length); for (int i = 0; i < cellValues.length; i++) { cellListBuilder.add( cellOf(rowKeys[cellRowIndices[i]], columnKeys[cellColumnIndices[i]], cellValues[i])); } return RegularImmutableTable.forOrderedComponents( cellListBuilder.build(), ImmutableSet.copyOf(rowKeys), ImmutableSet.copyOf(columnKeys)); }
@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()); }
public void testBuilderAddAll_iterator() { List<String> a = asList("a", "b"); List<String> b = asList("c", "d"); ImmutableList<String> list = new ImmutableList.Builder<String>().addAll(a.iterator()).addAll(b.iterator()).build(); assertEquals(asList("a", "b", "c", "d"), list); b.set(0, "f"); assertEquals(asList("a", "b", "c", "d"), list); }
public void testBuilderAdd() { ImmutableList<String> list = new ImmutableList.Builder<String>().add("a").add("b").add("a").add("c").build(); assertEquals(asList("a", "b", "a", "c"), list); }
public void testBuilderAdd_varargs() { ImmutableList<String> list = new ImmutableList.Builder<String>().add("a", "b", "a", "c").build(); assertEquals(asList("a", "b", "a", "c"), list); }
public void testBuilderAddAll_iterable() { List<String> a = asList("a", "b"); List<String> b = asList("c", "d"); ImmutableList<String> list = new ImmutableList.Builder<String>().addAll(a).addAll(b).build(); assertEquals(asList("a", "b", "c", "d"), list); b.set(0, "f"); assertEquals(asList("a", "b", "c", "d"), list); }