@Override public <S extends Comparable> Ordering<S> nullsLast() { Ordering<Comparable> result = nullsLast; if (result == null) { result = nullsLast = super.nullsLast(); } return (Ordering<S>) result; }
@Override public <S extends T> Ordering<S> nullsLast() { return ordering.nullsLast(); }
@Override public <S extends Comparable> Ordering<S> nullsLast() { Ordering<Comparable> result = nullsLast; if (result == null) { result = nullsLast = super.nullsLast(); } return (Ordering<S>) result; }
@Override public <S extends T> Ordering<S> nullsLast() { return ordering.nullsLast(); }
@Override public <S extends T> Ordering<S> reverse() { // ordering.reverse() might be optimized, so let it do its thing return ordering.reverse().nullsLast(); }
private static List<Artifact> sortedArtifacts(List<Artifact> artifacts) { List<Artifact> list = new ArrayList<>(artifacts); Collections.sort(list, Ordering.natural().nullsLast().onResultOf(Artifact::getFile)); return list; } }
@Override public <S extends T> Ordering<S> reverse() { // ordering.reverse() might be optimized, so let it do its thing return ordering.reverse().nullsLast(); }
@Override public TreeSet<String> get() { return new TreeSet<>(Ordering.natural().nullsLast()); } };
@Override public Ordering sortFieldOrdering(boolean ascending) { Ordering<Date> ordering = Ordering.<Date>natural().nullsLast(); if (!ascending) { ordering = ordering.reverse(); } return ordering; } }
@Override public Ordering sortFieldOrdering(boolean ascending) { Ordering<String> ordering = Ordering.from(String.CASE_INSENSITIVE_ORDER).nullsLast(); if (!ascending) { ordering = ordering.reverse(); } return ordering; } }
@Override <T> Scenario<?> mutate(Scenario<T> scenario) { List<T> newList = Lists.newArrayList(); for (T t : scenario.strictlyOrderedList) { if (t != null) { newList.add(t); } } newList.add(null); return new Scenario<T>(scenario.ordering.nullsLast(), newList, scenario.emptyArray); } },
public void testSortedCopy() { List<Integer> unsortedInts = Collections.unmodifiableList(Arrays.asList(5, 0, 3, null, 0, 9)); List<Integer> sortedInts = numberOrdering.nullsLast().sortedCopy(unsortedInts); assertEquals(Arrays.asList(0, 0, 3, 5, 9, null), sortedInts); assertEquals( Collections.emptyList(), numberOrdering.sortedCopy(Collections.<Integer>emptyList())); }
private static Ordering<ComponentDto> levelMetricOrdering(boolean isAscending, @Nullable MetricDto metric, Table<String, MetricDto, ComponentTreeData.Measure> measuresByComponentUuidAndMetric) { Ordering<Integer> ordering = Ordering.natural(); // inverse the order of org.sonar.api.measures.Metric.Level if (isAscending) { ordering = ordering.reverse(); } return ordering.nullsLast().onResultOf(new ComponentDtoToLevelIndex(metric, measuresByComponentUuidAndMetric)); }
public void testNullsLast() { Ordering<Integer> ordering = Ordering.natural().nullsLast(); Helpers.testComparator(ordering, 0, 1, Integer.MAX_VALUE, null); new EqualsTester() .addEqualityGroup(ordering, Ordering.natural().nullsLast()) .addEqualityGroup(numberOrdering.nullsLast()) .addEqualityGroup(Ordering.natural()) .testEquals(); }
@Parameters public static Collection<Object[]> parameters() { Comparator<String> nullsLast = Ordering.natural().nullsLast(); return Arrays.asList( new Object[][] { {new MapIteratorCache<String, String>(new HashMap<String, String>())}, {new MapIteratorCache<String, String>(new TreeMap<String, String>(nullsLast))}, {new MapRetrievalCache<String, String>(new HashMap<String, String>())}, {new MapRetrievalCache<String, String>(new TreeMap<String, String>(nullsLast))} }); }
public void testLeastOfIterator_simple_n_withNullElement() { List<Integer> list = Arrays.asList(3, 4, 5, null, -1); List<Integer> result = Ordering.natural().nullsLast().leastOf(list.iterator(), list.size()); assertTrue(result instanceof RandomAccess); assertListImmutable(result); assertEquals(Arrays.asList(-1, 3, 4, 5, null), result); }
public void testLeastOfIterable_simple_nMinusOne_withNullElement() { List<Integer> list = Arrays.asList(3, null, 5, -1); List<Integer> result = Ordering.natural().nullsLast().leastOf(list, list.size() - 1); assertTrue(result instanceof RandomAccess); assertListImmutable(result); assertEquals(ImmutableList.of(-1, 3, 5), result); }
public void testLeastOfIterable_simple_n_withNullElement() { List<Integer> list = Arrays.asList(3, 4, 5, null, -1); List<Integer> result = Ordering.natural().nullsLast().leastOf(list, list.size()); assertTrue(result instanceof RandomAccess); assertListImmutable(result); assertEquals(Arrays.asList(-1, 3, 4, 5, null), result); }
public void testComplicatedOrderingExample() { Integer nullInt = (Integer) null; Ordering<Iterable<Integer>> example = Ordering.<Integer>natural().nullsFirst().reverse().lexicographical().reverse().nullsLast(); List<Integer> list1 = Lists.newArrayList(); List<Integer> list2 = Lists.newArrayList(1); List<Integer> list3 = Lists.newArrayList(1, 1); List<Integer> list4 = Lists.newArrayList(1, 2); List<Integer> list5 = Lists.newArrayList(1, null, 2); List<Integer> list6 = Lists.newArrayList(2); List<Integer> list7 = Lists.newArrayList(nullInt); List<Integer> list8 = Lists.newArrayList(nullInt, nullInt); List<List<Integer>> list = Lists.newArrayList(list1, list2, list3, list4, list5, list6, list7, list8, null); List<List<Integer>> sorted = example.sortedCopy(list); // [[null, null], [null], [1, null, 2], [1, 1], [1, 2], [1], [2], [], null] assertThat(sorted) .containsExactly( Lists.newArrayList(nullInt, nullInt), Lists.newArrayList(nullInt), Lists.newArrayList(1, null, 2), Lists.newArrayList(1, 1), Lists.newArrayList(1, 2), Lists.newArrayList(1), Lists.newArrayList(2), Lists.newArrayList(), null) .inOrder(); }
public void testLeastOfIterator_simple_nMinusOne_withNullElement() { Iterator<Integer> itr = Iterators.forArray(3, null, 5, -1); List<Integer> result = Ordering.natural().nullsLast().leastOf(itr, 3); assertTrue(result instanceof RandomAccess); assertListImmutable(result); assertEquals(ImmutableList.of(-1, 3, 5), result); }