@Override protected List<String> create(String[] elements) { List<String> list = asList(elements); Collections.reverse(list); return ImmutableList.copyOf(list).reverse(); } }
@Override public Iterable<E> order(List<E> insertionOrder) { return ImmutableList.copyOf(super.order(insertionOrder)).reverse(); } })
@GwtIncompatible // NavigableSet @Override public UnmodifiableIterator<E> descendingIterator() { return elements.reverse().iterator(); }
@Override public ImmutableMap<Range<K>, V> asDescendingMapOfRanges() { if (ranges.isEmpty()) { return ImmutableMap.of(); } RegularImmutableSortedSet<Range<K>> rangeSet = new RegularImmutableSortedSet<>(ranges.reverse(), Range.<K>rangeLexOrdering().reverse()); return new ImmutableSortedMap<>(rangeSet, values.reverse()); }
@Override Entry<E> getEntry(int index) { return forward.entrySet().asList().reverse().get(index); }
@GwtIncompatible // NavigableSet @Override public UnmodifiableIterator<E> descendingIterator() { return elements.reverse().iterator(); }
@Override public ImmutableSet<Range<C>> asDescendingSetOfRanges() { if (ranges.isEmpty()) { return ImmutableSet.of(); } return new RegularImmutableSortedSet<>(ranges.reverse(), Range.<C>rangeLexOrdering().reverse()); }
public ImageLayers<T> build() { if (!removeDuplicates) { return new ImageLayers<>(ImmutableList.copyOf(layers), layerDigestsBuilder.build()); } // LinkedHashSet maintains the order but keeps the first occurrence. Keep last occurrence by // adding elements in reverse, and then reversing the result Set<T> dedupedButReversed = new LinkedHashSet<T>(Lists.reverse(this.layers)); ImmutableList<T> deduped = ImmutableList.copyOf(dedupedButReversed).reverse(); return new ImageLayers<>(deduped, layerDigestsBuilder.build()); } }
@SuppressWarnings("unchecked") private void rollback(Map<EntityDescriptor, Object> entities) { final ImmutableList<Map.Entry<EntityDescriptor, Object>> entries = ImmutableList.copyOf(entities.entrySet()); for (Map.Entry<EntityDescriptor, Object> entry : entries.reverse()) { final EntityDescriptor entityDescriptor = entry.getKey(); final Object entity = entry.getValue(); final EntityFacade facade = entityFacades.getOrDefault(entityDescriptor.type(), UnsupportedEntityFacade.INSTANCE); LOG.debug("Removing entity {}", entityDescriptor); facade.delete(entity); } }
@Override ImmutableSortedSet<E> createDescendingSet() { Comparator<? super E> reversedOrder = Collections.reverseOrder(comparator); return isEmpty() ? emptySet(reversedOrder) : new RegularImmutableSortedSet<E>(elements.reverse(), reversedOrder); } }
public static <T> JsonExtractor<T> generateExtractor(String path, JsonExtractor<T> rootExtractor, boolean exceptionOnOutOfBounds) { ImmutableList<String> tokens = ImmutableList.copyOf(new JsonPathTokenizer(path)); JsonExtractor<T> jsonExtractor = rootExtractor; for (String token : tokens.reverse()) { jsonExtractor = new ObjectFieldJsonExtractor<>(token, jsonExtractor, exceptionOnOutOfBounds); } return jsonExtractor; }
/** * 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 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<>( (RegularImmutableSortedSet<K>) keySet.descendingSet(), valueList.reverse(), this); } } return result; }
@Test(dataProvider = "caches") @CacheSpec(implementation = Implementation.Caffeine, population = {Population.PARTIAL, Population.FULL}, expiry = CacheExpiry.ACCESS, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void youngest_order(CacheContext context, VarExpiration<Integer, Integer> expireAfterVar) { Map<Integer, Integer> youngest = expireAfterVar.youngest(Integer.MAX_VALUE); Set<Integer> keys = new LinkedHashSet<>(ImmutableList.copyOf(youngest.keySet()).reverse()); assertThat(keys, contains(Iterables.toArray(keys, Integer.class))); }
public void assertValues(T expectedMin, T expectedMax, List<T> values) { assertValuesInternal(expectedMin, expectedMax, values); assertValuesInternal(expectedMin, expectedMax, ImmutableList.copyOf(values).reverse()); List<T> randomOrder = new ArrayList<>(values); Collections.shuffle(randomOrder, new Random(42)); assertValuesInternal(expectedMin, expectedMax, randomOrder); }
@Test(dataProvider = "caches") @CacheSpec(implementation = Implementation.Caffeine, population = {Population.PARTIAL, Population.FULL}, expireAfterWrite = Expire.ONE_MINUTE, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void youngest_order(CacheContext context, @ExpireAfterWrite Expiration<Integer, Integer> expireAfterWrite) { Map<Integer, Integer> youngest = expireAfterWrite.youngest(Integer.MAX_VALUE); Set<Integer> keys = new LinkedHashSet<>(ImmutableList.copyOf(youngest.keySet()).reverse()); assertThat(keys, contains(Iterables.toArray(keys, Integer.class))); }
@Test(dataProvider = "caches") @CacheSpec(implementation = Implementation.Caffeine, population = Population.FULL, refreshAfterWrite = Expire.ONE_MINUTE, advanceOnPopulation = Advance.ONE_MINUTE, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void youngest_order(CacheContext context, @RefreshAfterWrite Expiration<Integer, Integer> refreshAfterWrite) { Map<Integer, Integer> youngest = refreshAfterWrite.youngest(Integer.MAX_VALUE); Set<Integer> keys = new LinkedHashSet<>(ImmutableList.copyOf(youngest.keySet()).reverse()); assertThat(keys, contains(context.original().keySet().toArray(new Integer[0]))); }
@Test(dataProvider = "caches") @CacheSpec(implementation = Implementation.Caffeine, population = {Population.PARTIAL, Population.FULL}, expireAfterAccess = Expire.ONE_MINUTE, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void youngest_order(CacheContext context, @ExpireAfterAccess Expiration<Integer, Integer> expireAfterAccess) { Map<Integer, Integer> youngest = expireAfterAccess.youngest(Integer.MAX_VALUE); Set<Integer> keys = new LinkedHashSet<>(ImmutableList.copyOf(youngest.keySet()).reverse()); assertThat(keys, contains(context.original().keySet().toArray(new Integer[0]))); }
@AndroidIncompatible // slow public void testAsMapOfRanges() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { ImmutableRangeMap<Integer, Integer> rangeMap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); ImmutableMap<Range<Integer>, Integer> expectedAsMap = ImmutableMap.of(range1, 1, range2, 2); ImmutableMap<Range<Integer>, Integer> asMap = rangeMap.asMapOfRanges(); ImmutableMap<Range<Integer>, Integer> descendingMap = rangeMap.asDescendingMapOfRanges(); assertEquals(expectedAsMap, asMap); assertEquals(expectedAsMap, descendingMap); SerializableTester.reserializeAndAssert(asMap); SerializableTester.reserializeAndAssert(descendingMap); assertEquals( ImmutableList.copyOf(asMap.entrySet()).reverse(), ImmutableList.copyOf(descendingMap.entrySet())); for (Range<Integer> query : RANGES) { assertEquals(expectedAsMap.get(query), asMap.get(query)); } } } } }