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)); }
@Override public List<String> order(List<String> insertionOrder) { return Ordering.natural().sortedCopy(insertionOrder); } }
/** * Returns a {@code TopKSelector} that collects the greatest {@code k} elements added to it, * relative to the specified comparator, and returns them via {@link #topK} in descending order. * * @throws IllegalArgumentException if {@code k < 0} */ public static <T> TopKSelector<T> greatest(int k, Comparator<? super T> comparator) { return new TopKSelector<T>(Ordering.from(comparator).reverse(), k); }
DescendingImmutableSortedSet(ImmutableSortedSet<E> forward) { super(Ordering.from(forward.comparator()).reverse()); this.forward = forward; }
/** Returns a newly-created immutable multimap. */ public ImmutableMultimap<K, V> build() { Collection<Map.Entry<K, Collection<V>>> mapEntries = builderMap.entrySet(); if (keyComparator != null) { mapEntries = Ordering.from(keyComparator).<K>onKeys().immutableSortedCopy(mapEntries); } return ImmutableListMultimap.fromMapEntries(mapEntries, valueComparator); } }
Set<String> hiddenColumns = ImmutableSet.of(); if (comment != null && comment.startsWith(PRESTO_COMMENT_METADATA)) { String columnOrderingString = comment.substring(PRESTO_COMMENT_METADATA.length()); List<String> explicitColumnOrder = new ArrayList<>(ImmutableList.copyOf(transform(extras, ExtraColumnMetadata::getName))); hiddenColumns = ImmutableSet.copyOf(transform(filter(extras, ExtraColumnMetadata::isHidden), ExtraColumnMetadata::getName)); columnNames = Ordering.explicit(explicitColumnOrder).sortedCopy(columnNames); ImmutableList.Builder<CassandraColumnHandle> columnHandles = ImmutableList.builder(); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, true, false, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, false, true, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, false, false, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); List<CassandraColumnHandle> sortedColumnHandles = columnHandles.build().stream() .sorted(comparing(CassandraColumnHandle::getOrdinalPosition)) .collect(toList());
@SuppressWarnings("unchecked") // raw array @Override <T> Scenario<?> mutate(Scenario<T> scenario) { List<Composite<T>> composites = Lists.newArrayList(); for (T t : scenario.strictlyOrderedList) { composites.add(new Composite<T>(t, 1)); composites.add(new Composite<T>(t, 2)); } Ordering<Composite<T>> ordering = scenario .ordering .onResultOf(Composite.<T>getValueFunction()) .compound(Ordering.natural()); return new Scenario<Composite<T>>(ordering, composites, new Composite[0]); } },
public void testToSortedList_withDuplicates() { assertEquals( Lists.newArrayList(4, 3, 1, 1), fluent(1, 4, 1, 3).toSortedList(Ordering.<Integer>natural().reverse())); }
public void testOrderedPermutationSetRepeatedElementsSize() { List<Integer> list = newArrayList(1, 1, 1, 1, 2, 2, 3); Collection<List<Integer>> permutations = Collections2.orderedPermutations(list, Ordering.natural()); assertPermutationsCount(105, permutations); }
public void testMergeSorted_skipping_pyramid() { List<Iterable<Integer>> iterables = Lists.newLinkedList(); List<Integer> allIntegers = Lists.newArrayList(); for (int i = 0; i < 20; i++) { List<Integer> list = Lists.newLinkedList(); for (int j = 0; j < i; j++) { list.add(j * i); allIntegers.add(j * i); } iterables.add(Ordering.natural().sortedCopy(list)); } verifyMergeSorted(iterables, allIntegers); }
if (iterable == null) return ImmutableList.of(); try { if (key == null || key.length() == 0) { Object first = Iterables.getFirst(iterable, null); if (first instanceof Map) { Object firstKey = Iterables.getFirst(((Map) first).keySet(), null); if (firstKey != null && firstKey instanceof String) return sort(iterable, (String) firstKey); return ImmutableList.copyOf(Ordering.natural().sortedCopy((Iterable<? extends Comparable>) iterable)); return ImmutableList.copyOf(keyOrdering.sortedCopy(iterable)); } catch (NullPointerException e) { throw new IllegalArgumentException("Invalid key for this type of object: " + key);
private static void runLeastOfComparison(int iterations, int elements, int seeds) { Random random = new Random(42); Ordering<Integer> ordering = Ordering.natural(); for (int i = 0; i < iterations; i++) { List<Integer> list = Lists.newArrayList(); for (int j = 0; j < elements; j++) { list.add(random.nextInt(10 * i + j + 1)); } for (int seed = 1; seed < seeds; seed++) { int k = random.nextInt(10 * seed); assertEquals(ordering.sortedCopy(list).subList(0, k), ordering.leastOf(list, k)); } } }
void testSortedCopy() { List<T> shuffledList = Lists.newArrayList(strictlyOrderedList); shuffledList = shuffledCopy(shuffledList, new Random(5)); assertEquals(strictlyOrderedList, ordering.sortedCopy(shuffledList)); if (!strictlyOrderedList.contains(null)) { assertEquals(strictlyOrderedList, ordering.immutableSortedCopy(shuffledList)); } } }
@Nonnull @Override public Iterator<BuilderMethod> iterator() { return Iterators.mergeSorted( ImmutableList.of(directMethods.iterator(), virtualMethods.iterator()), Ordering.natural()); }
.orderedBy(Ordering.from(UnsignedBytes.lexicographicalComparator()).onResultOf(key -> key.getColumnName())); for (int i = 0 ; i < totalPuts ; i++) { put(t, "row1", "col" + i, "v" + i); t.getRowsColumnRange(TEST_TABLE, ImmutableList.of(row), BatchColumnRangeSelection.create(PtBytes.EMPTY_BYTE_ARRAY, PtBytes.EMPTY_BYTE_ARRAY, 1)); List<Map.Entry<Cell, byte[]>> expected = ImmutableList.copyOf(writes.build().entrySet()); verifyMatchingResult(expected, row, columnRange); t.getRowsColumnRange(TEST_TABLE, ImmutableList.of(row), BatchColumnRangeSelection.create(PtBytes.toBytes("col"), PtBytes.EMPTY_BYTE_ARRAY, 1)); verifyMatchingResult(expected, row, columnRange); t.getRowsColumnRange(TEST_TABLE, ImmutableList.of(row), BatchColumnRangeSelection.create(PtBytes.EMPTY_BYTE_ARRAY, expected.get(expected.size() - 1).getKey().getColumnName(), 1)); verifyMatchingResult(ImmutableList.copyOf(Iterables.limit(expected, 100)), row, columnRange);
@Override <T> Scenario<?> mutate(Scenario<T> scenario) { List<T> newList = Lists.newArrayList(scenario.strictlyOrderedList); Collections.reverse(newList); return new Scenario<T>(scenario.ordering.reverse(), newList, scenario.emptyArray); } },
@Override <T> Scenario<?> mutate(final Scenario<T> scenario) { Ordering<Integer> ordering = scenario.ordering.onResultOf( new Function<Integer, T>() { @Override public T apply(@Nullable Integer from) { return scenario.strictlyOrderedList.get(from); } }); List<Integer> list = Lists.newArrayList(); for (int i = 0; i < scenario.strictlyOrderedList.size(); i++) { list.add(i); } return new Scenario<>(ordering, list, new Integer[0]); } },
public static final @Nullable Tuple4<Long, Long, Long, Long> contentSizeStats( JavaRDD<ApacheAccessLog> accessLogRDD) { JavaDoubleRDD contentSizes = accessLogRDD.mapToDouble(new GetContentSize()).cache(); long count = contentSizes.count(); if (count == 0) { return null; } Object ordering = Ordering.natural(); final Comparator<Double> cmp = (Comparator<Double>)ordering; return new Tuple4<>(count, contentSizes.reduce(new SumReducer()).longValue(), contentSizes.min(cmp).longValue(), contentSizes.max(cmp).longValue()); }
@Test public void getDeprecatedKeys_returns_keys_in_order_of_addDeprecatedKeys_calls() { Set<RuleKey> ruleKeys = ImmutableSet.of(RuleKey.of("foo", "AAA"), RuleKey.of("bar", "CCCC"), RuleKey.of("doh", "CCCC"), RuleKey.of("foo", "BBBBBBBBBB")); List<RuleKey> sortedRuleKeys = ruleKeys.stream().sorted(Ordering.natural().onResultOf(RuleKey::toString)).collect(Collectors.toList()); // ensure we don't have the same order Assume.assumeTrue(!ImmutableList.copyOf(ruleKeys).equals(sortedRuleKeys)); String repositoryKey = "foo"; String ruleKey = "doh"; RulesDefinition.NewRepository newRepository = context.createRepository(repositoryKey, "bar"); RulesDefinition.NewRule newRule = newRepository.createRule(ruleKey) .setName("doh rule") .setHtmlDescription("doh description"); sortedRuleKeys.forEach(r -> newRule.addDeprecatedRuleKey(r.repository(), r.rule())); newRepository.done(); RulesDefinition.Repository repository = context.repository(repositoryKey); RulesDefinition.Rule rule = repository.rule(ruleKey); assertThat(ImmutableList.copyOf(rule.deprecatedRuleKeys())) .isEqualTo(sortedRuleKeys); }