@Override public final Iterator<HStoreFile> getCandidateFilesForRowKeyBefore(KeyValue targetKey) { return this.storefiles.reverse().iterator(); }
@GwtIncompatible // NavigableSet @Override public UnmodifiableIterator<E> descendingIterator() { return elements.reverse().iterator(); }
@Override ImmutableSortedSet<E> createDescendingSet() { Comparator<? super E> reversedOrder = Collections.reverseOrder(comparator); return isEmpty() ? emptySet(reversedOrder) : new RegularImmutableSortedSet<E>(elements.reverse(), reversedOrder); } }
@Override public ImmutableMap<Range<K>, V> asDescendingMapOfRanges() { if (ranges.isEmpty()) { return ImmutableMap.of(); } RegularImmutableSortedSet<Range<K>> rangeSet = new RegularImmutableSortedSet<Range<K>>( ranges.reverse(), Range.<K>rangeLexOrdering().reverse()); return new ImmutableSortedMap<Range<K>, V>(rangeSet, values.reverse()); }
@Override Entry<E> getEntry(int index) { return forward.entrySet().asList().reverse().get(index); }
/** * Returns a reversed view of the specified list. For example, {@code * Lists.reverse(Arrays.asList(1, 2, 3))} returns a list containing {@code 3, * 2, 1}. The returned list is backed by this list, so changes in the returned * list are reflected in this list, and vice-versa. The returned list supports * all of the optional list operations supported by this list. * * <p>The returned list is random-access if the specified list is random * access. * * @since 7.0 */ public static <T> List<T> reverse(List<T> list) { if (list instanceof ImmutableList) { return ((ImmutableList<T>) list).reverse(); } else if (list instanceof ReverseList) { return ((ReverseList<T>) list).getForwardList(); } else if (list instanceof RandomAccess) { return new RandomAccessReverseList<>(list); } else { return new ReverseList<>(list); } }
@Override public ImmutableSet<Range<C>> asDescendingSetOfRanges() { if (ranges.isEmpty()) { return ImmutableSet.of(); } return new RegularImmutableSortedSet<Range<C>>( ranges.reverse(), Range.<C>rangeLexOrdering().reverse()); }
@Override public ImmutableList<E> subList(int fromIndex, int toIndex) { checkPositionIndexes(fromIndex, toIndex, size()); return forwardList.subList(reversePosition(toIndex), reversePosition(fromIndex)).reverse(); }
@Override public ImmutableSortedMap<K, V> descendingMap() { // TODO(kevinb): the descendingMap is never actually cached at all. Either it should be or the // code below simplified. ImmutableSortedMap<K, V> result = descendingMap; if (result == null) { if (isEmpty()) { return result = emptyMap(Ordering.from(comparator()).reverse()); } else { return result = new ImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet.descendingSet(), valueList.reverse(), this); } } return result; }