BitSet<T> fromBitMaskNoCopy(long[] elements) { switch (elements.length) { case 0: return createEmpty(); case 1: return new BitSet1<>(fromInt, toInt, elements[0]); case 2: return new BitSet2<>(fromInt, toInt, elements[0], elements[1]); default: return new BitSetN<>(fromInt, toInt, elements); } }
static <T> Stream<Node<T>> traverseInOrder(Node<T> node) { if (node.isLeaf()) { return Stream.of(node); } else { final io.vavr.collection.List<Node<T>> children = node.getChildren(); return children .tail() .foldLeft(Stream.<Node<T>> empty(), (acc, child) -> acc.appendAll(traverseInOrder(child))) .prepend(node) .prependAll(traverseInOrder(children.head())); } }
static <T> Stream<T> apply(io.vavr.collection.List<T> front, io.vavr.collection.List<T> rear, Stream<T> remaining) { if (remaining.isEmpty()) { return remaining; } else if (front.isEmpty()) { return apply(rear.reverse(), io.vavr.collection.List.empty(), remaining); } else { return Stream.cons(front.head(), () -> apply(front.tail(), rear.prepend(remaining.head()), remaining.tail())); } } }
@Override public TreeSet<T> drop(int n) { if (n <= 0 || isEmpty()) { return this; } else if (n >= length()) { return empty(tree.comparator()); } else { return TreeSet.ofAll(tree.comparator(), iterator().drop(n)); } }
@Override public TreeSet<T> takeRight(int n) { if (n <= 0) { return empty(tree.comparator()); } else if (n >= length()) { return this; } else { return TreeSet.ofAll(tree.comparator(), iterator().takeRight(n)); } }
static <T> Stream<Node<T>> traversePostOrder(Node<T> node) { return node .getChildren() .foldLeft(Stream.<Node<T>> empty(), (acc, child) -> acc.appendAll(traversePostOrder(child))) .append(node); }
@Override public <U> Set<U> scanLeft(U zero, BiFunction<? super U, ? super T, ? extends U> operation) { if (zero instanceof Comparable) { final Comparator<U> comparator = Comparators.naturalComparator(); return Collections.scanLeft(this, zero, operation, iter -> TreeSet.ofAll(comparator, iter)); } else { return Collections.scanLeft(this, zero, operation, HashSet::ofAll); } }
@Override public <U> Set<U> scanRight(U zero, BiFunction<? super T, ? super U, ? extends U> operation) { if (zero instanceof Comparable) { final Comparator<U> comparator = Comparators.naturalComparator(); return Collections.scanRight(this, zero, operation, iter -> TreeSet.ofAll(comparator, iter)); } else { return Collections.scanRight(this, zero, operation, HashSet::ofAll); } }
@GwtIncompatible("BigDecimalHelper is GwtIncompatible") static Iterator<Double> rangeBy(double from, double toExclusive, double step) { final BigDecimal fromDecimal = asDecimal(from), toDecimal = asDecimal(toExclusive), stepDecimal = asDecimal(step); return rangeBy(fromDecimal, toDecimal, stepDecimal).map(BigDecimal::doubleValue); }
BitMappedTrie<T> prependAll(Iterable<? extends T> iterable) { final Collections.IterableWithSize<? extends T> iter = withSize(iterable); try { return prepend(iter.reverseIterator(), iter.size()); } catch (ClassCastException ignored) { return boxed().prepend(iter.reverseIterator(), iter.size()); } } private BitMappedTrie<T> prepend(java.util.Iterator<? extends T> iterator, int size) {
BitMappedTrie<T> appendAll(Iterable<? extends T> iterable) { final Collections.IterableWithSize<? extends T> iter = withSize(iterable); try { return append(iter.iterator(), iter.size()); } catch (ClassCastException ignored) { return boxed().append(iter.iterator(), iter.size()); } } private BitMappedTrie<T> append(java.util.Iterator<? extends T> iterator, int size) {
@Override public <K2> TreeMap<K2, V> mapKeys(Function<? super K, ? extends K2> keyMapper, BiFunction<? super V, ? super V, ? extends V> valueMerge) { final Comparator<K2> comparator = Comparators.naturalComparator(); return Collections.mapKeys(this, TreeMap.<K2, V> empty(comparator), keyMapper, valueMerge); }
/** * Returns the empty TreeMap using the given key comparator. * * @param <K> The key type * @param <V> The value type * @param keyComparator The comparator used to sort the entries by their key. * @return A new empty TreeMap. */ public static <K, V> TreeMap<K, V> empty(Comparator<? super K> keyComparator) { return new TreeMap<>(RedBlackTree.empty(EntryComparator.of(keyComparator))); }