public void testReverse() {
Ordering<Number> reverseOrder = numberOrdering.reverse();
Helpers.testComparator(reverseOrder, Integer.MAX_VALUE, 1, 0, -1, Integer.MIN_VALUE);
new EqualsTester()
.addEqualityGroup(reverseOrder, numberOrdering.reverse())
.addEqualityGroup(Ordering.natural().reverse())
.addEqualityGroup(Collections.reverseOrder())
.testEquals();
}
@Override
public Iterator<? extends T> iterator(long first, long count) {
Collection<T> data = dataModel.getObject();
if (data == null || data.size() == 0) return Iterators.emptyIterator();
Iterator<T> it;
final SortParam<S> sortParam = getSort();
if (sortParam != null && sortParam.getProperty() != null) {
Ordering<T> ordering =
Ordering.natural()
.nullsFirst()
.onResultOf(
new Function<T, Comparable<?>>() {
@Override
public Comparable<?> apply(T input) {
return comparableValue(input, sortParam.getProperty());
}
});
if (!sortParam.isAscending()) ordering = ordering.reverse();
it = ordering.sortedCopy(data).iterator();
} else {
it = data.iterator();
}
if (first > 0) Iterators.advance(it, (int) first);
return count >= 0 ? Iterators.limit(it, (int) count) : it;
}
@Override
Ordering sortFieldOrdering(boolean ascending) {
Ordering<Integer> ordering = Ordering.<Integer>natural().nullsLast();
if (!ascending) {
ordering = ordering.reverse();
}
return ordering;
}
@Override
Ordering sortFieldOrdering(boolean ascending) {
Ordering<String> ordering = Ordering.from(String.CASE_INSENSITIVE_ORDER);
if (!ascending) {
ordering = ordering.reverse();
}
return ordering;
}
public MarkMarkers(Configuration conf) throws IOException {
InputStream in = conf.openModelStream("discourse-markers", "en-discourse-markers");
try {
// sort so that we prefer the longest markers
markers = CompareLength.reverse().sortedCopy(read(in));
} finally {
in.close();
}
}
public void testAllEqual() {
Ordering<Object> comparator = Ordering.allEqual();
assertSame(comparator, comparator.reverse());
assertEquals(comparator.compare(null, null), 0);
assertEquals(comparator.compare(new Object(), new Object()), 0);
assertEquals(comparator.compare("apples", "oranges"), 0);
assertSame(comparator, reserialize(comparator));
assertEquals("Ordering.allEqual()", comparator.toString());
List<String> strings = ImmutableList.of("b", "a", "d", "c");
assertEquals(strings, comparator.sortedCopy(strings));
assertEquals(strings, comparator.immutableSortedCopy(strings));
}
public void testReverseOfReverseSameAsForward() {
// Not guaranteed by spec, but it works, and saves us from testing
// exhaustively
assertSame(numberOrdering, numberOrdering.reverse().reverse());
}
@Override
public List<MyBusinessObject> findByNegativeAccountBalanceOrderedByIdDescending() {
return getHelper()
.findAllOrderedWhere(ASCENDING_ID.reverse(), Predicates.not(POSITIVE_ACCOUNT_BALANCE));
}