ImmutableList.Builder<AbstractFuture<T>> delegatesBuilder = ImmutableList.builder(); for (int i = 0; i < copy.length; i++) { delegatesBuilder.add(new InCompletionOrderFuture<T>(state)); final ImmutableList<AbstractFuture<T>> delegates = delegatesBuilder.build(); for (int i = 0; i < copy.length; i++) { final int localI = i;
new ImmutableList.Builder<Range<C>>(ranges.size()); Collections.sort(ranges, Range.<C>rangeLexOrdering()); PeekingIterator<Range<C>> peekingItr = Iterators.peekingIterator(ranges.iterator()); mergedRangesBuilder.add(range); ImmutableList<Range<C>> mergedRanges = mergedRangesBuilder.build(); if (mergedRanges.isEmpty()) { return of();
/** * Returns the generic interfaces that this type directly {@code implements}. This method is * similar but different from {@link Class#getGenericInterfaces()}. For example, {@code new * TypeToken<List<String>>() {}.getGenericInterfaces()} will return a list that contains * {@code new TypeToken<Iterable<String>>() {}}; while {@code List.class.getGenericInterfaces()} * will return an array that contains {@code Iterable<T>}, where the {@code T} is the type * variable declared by interface {@code Iterable}. * * <p>If this type is a type variable or wildcard, its upper bounds are examined and those that * are either an interface or upper-bounded only by interfaces are returned. This means that the * returned types could include type variables too. */ final ImmutableList<TypeToken<? super T>> getGenericInterfaces() { if (runtimeType instanceof TypeVariable) { return boundsAsInterfaces(((TypeVariable<?>) runtimeType).getBounds()); } if (runtimeType instanceof WildcardType) { return boundsAsInterfaces(((WildcardType) runtimeType).getUpperBounds()); } ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder(); for (Type interfaceType : getRawType().getGenericInterfaces()) { @SuppressWarnings("unchecked") // interface of T TypeToken<? super T> resolvedInterface = (TypeToken<? super T>) resolveSupertype(interfaceType); builder.add(resolvedInterface); } return builder.build(); }
return encodedPaths; // return the original collection as no encoded SchemaPath was found } else { ImmutableList.Builder<SchemaPath> builder = new ImmutableList.Builder<>(); for (String decodedString : decodedStrings) { if ("*".equals(decodedString) || "`*`".equals(decodedString)) { builder.add(SchemaPath.STAR_COLUMN); } else { builder.add(SchemaPath.parseFromString(decodedString)); return builder.build();
long estimatedSize = 0L; ImmutableList.Builder<Spliterator<? extends T>> splitrsBuilder = new ImmutableList.Builder<>(streams.length); for (Stream<? extends T> stream : streams) { isParallel |= stream.isParallel(); Spliterator<? extends T> splitr = stream.spliterator(); splitrsBuilder.add(splitr); characteristics &= splitr.characteristics(); estimatedSize = LongMath.saturatedAdd(estimatedSize, splitr.estimateSize()); splitrsBuilder.build().spliterator(), splitr -> (Spliterator<T>) splitr, characteristics,
static <E> Set<List<E>> create(List<? extends Set<? extends E>> sets) { ImmutableList.Builder<ImmutableSet<E>> axesBuilder = new ImmutableList.Builder<ImmutableSet<E>>(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<Range<K>>(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<K, V>(rangesBuilder.build(), valuesBuilder.build()); } }
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()); }
/** * Helper method to create {@link FunctionExprNode} from {@code List<String>}. * @param fieldName Name of the filed on which the like expression is applied. * @param valuesFilter a list of values * @return {@link FunctionExprNode} for given arguments. Null if the <code>valuesFilter</code> is null. */ private static FunctionExprNode createInFunctionExprNode(String fieldName, List<String> valuesFilter) { if (valuesFilter == null) { return null; } ImmutableList.Builder<ExprNode> nodes = ImmutableList.builder(); nodes.add(new FieldExprNode(fieldName)); for(String type: valuesFilter) { nodes.add(new ConstantExprNode(type)); } return new FunctionExprNode(IN_FUNCTION, nodes.build()); }
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<Cell<Object, Object, Object>>(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)); }
public RexNode go(RexNode rex) { if (rex instanceof RexCall) { ImmutableList.Builder<RexNode> builder = ImmutableList.builder(); final RexCall call = (RexCall) rex; for (RexNode operand : call.operands) { builder.add(go(operand)); } return call.clone(call.getType(), builder.build()); } else if (rex instanceof RexInputRef) { RexInputRef var = (RexInputRef) rex; int index = var.getIndex(); return rexBuilder.makeInputRef(var.getType(), inputRefMap.get(index)); } else { return rex; } } }
/** * 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(); } }
/** * Returns all declared parameters of this {@code Invokable}. Note that if this is a constructor * of a non-static inner class, unlike {@link Constructor#getParameterTypes}, the hidden * {@code this} parameter of the enclosing class is excluded from the returned parameters. */ public final ImmutableList<Parameter> getParameters() { Type[] parameterTypes = getGenericParameterTypes(); Annotation[][] annotations = getParameterAnnotations(); ImmutableList.Builder<Parameter> builder = ImmutableList.builder(); for (int i = 0; i < parameterTypes.length; i++) { builder.add(new Parameter(this, i, TypeToken.of(parameterTypes[i]), annotations[i])); } return builder.build(); }
private ImmutableList<ProjectedColumnInfo> initCols(final Schema schema) { ImmutableList.Builder<ProjectedColumnInfo> pciBuilder = ImmutableList.builder(); ColumnDto column; for (int i = 0; i < schema.getNumberOfColumns(); i++) { column = schema.getColumnByIndex(i); final String name = column.getColumnName().toLowerCase(); final PcapTypes type = column.getColumnType(); TypeProtos.MinorType minorType = TYPES.get(type); ProjectedColumnInfo pci = getProjectedColumnInfo(column, name, minorType); pciBuilder.add(pci); } return pciBuilder.build(); }
private static final Iterable<ConvertSupport> getSupportedConvertOps() { // A set would be more appropriate but it's not possible to produce // duplicates, and an iterable is all we need. ImmutableList.Builder<ConvertSupport> supportedConvertedOps = ImmutableList.builder(); for(MinorType from: MinorType.values()) { for(MinorType to: MinorType.values()) { if (TypeCastRules.isCastable(from, to)) { supportedConvertedOps.add(ConvertSupport.newBuilder().setFrom(from).setTo(to).build()); } } } return supportedConvertedOps.build(); } /**
public LogicalPlan build() { return new LogicalPlan(this.planProperties, this.storageEngines.build(), this.operators.build()); } }
@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<Range<K>>(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<K, V>(rangesBuilder.build(), valuesBuilder.build()); }