private void buildNaturalOrdering() { if (config.tagOrderBy == OrderBy.NATURAL) config.tagOrdering = Ordering.natural(); if (config.operationOrderBy == OrderBy.NATURAL) config.operationOrdering = OPERATION_PATH_NATURAL_ORDERING.compound(OPERATION_METHOD_NATURAL_ORDERING); if (config.definitionOrderBy == OrderBy.NATURAL) config.definitionOrdering = Ordering.natural(); if (config.parameterOrderBy == OrderBy.NATURAL) config.parameterOrdering = PARAMETER_IN_NATURAL_ORDERING.compound(PARAMETER_NAME_NATURAL_ORDERING); if (config.propertyOrderBy == OrderBy.NATURAL) config.propertyOrdering = Ordering.natural(); if (config.responseOrderBy == OrderBy.NATURAL) config.responseOrdering = Ordering.natural(); }
public void testCompound_instance_generics() { Ordering<Object> objects = Ordering.explicit((Object) 1); Ordering<Number> numbers = Ordering.explicit((Number) 1); Ordering<Integer> integers = Ordering.explicit(1); // Like by like equals like Ordering<Number> a = numbers.compound(numbers); // The compound takes the more specific type of the two, regardless of order Ordering<Number> b = numbers.compound(objects); Ordering<Number> c = objects.compound(numbers); Ordering<Integer> d = numbers.compound(integers); Ordering<Integer> e = integers.compound(numbers); // This works with three levels too (IDEA falsely reports errors as noted // below. Both javac and eclipse handle these cases correctly.) Ordering<Number> f = numbers.compound(objects).compound(objects); // bad IDEA Ordering<Number> g = objects.compound(numbers).compound(objects); Ordering<Number> h = objects.compound(objects).compound(numbers); Ordering<Number> i = numbers.compound(objects.compound(objects)); Ordering<Number> j = objects.compound(numbers.compound(objects)); // bad IDEA Ordering<Number> k = objects.compound(objects.compound(numbers)); // You can also arbitrarily assign a more restricted type - not an intended // feature, exactly, but unavoidable (I think) and harmless Ordering<Integer> l = objects.compound(numbers); // This correctly doesn't work: // Ordering<Object> m = numbers.compound(objects); // Sadly, the following works in javac 1.6, but at least it fails for // eclipse, and is *correctly* highlighted red in IDEA. // Ordering<Object> n = objects.compound(numbers); }
private static List<ComponentDto> sortComponents(List<ComponentDto> components, Request wsRequest) { List<String> sortParameters = wsRequest.getSort(); if (sortParameters == null || sortParameters.isEmpty()) { return components; } boolean isAscending = wsRequest.getAsc(); Map<String, Ordering<ComponentDto>> orderingsBySortField = ImmutableMap.<String, Ordering<ComponentDto>>builder() .put(NAME_SORT, stringOrdering(isAscending, ComponentDto::name)) .put(QUALIFIER_SORT, stringOrdering(isAscending, ComponentDto::qualifier)) .put(PATH_SORT, stringOrdering(isAscending, ComponentDto::path)) .build(); String firstSortParameter = sortParameters.get(0); Ordering<ComponentDto> primaryOrdering = orderingsBySortField.get(firstSortParameter); if (sortParameters.size() > 1) { for (int i = 1; i < sortParameters.size(); i++) { String secondarySortParameter = sortParameters.get(i); Ordering<ComponentDto> secondaryOrdering = orderingsBySortField.get(secondarySortParameter); primaryOrdering = primaryOrdering.compound(secondaryOrdering); } } return primaryOrdering.immutableSortedCopy(components); }
public static List<ComponentDto> sortComponents(List<ComponentDto> components, ComponentTreeRequest wsRequest, List<MetricDto> metrics, Table<String, MetricDto, ComponentTreeData.Measure> measuresByComponentUuidAndMetric) { List<String> sortParameters = wsRequest.getSort(); if (sortParameters == null || sortParameters.isEmpty()) { return components; } boolean isAscending = wsRequest.getAsc(); Map<String, Ordering<ComponentDto>> orderingsBySortField = ImmutableMap.<String, Ordering<ComponentDto>>builder() .put(NAME_SORT, componentNameOrdering(isAscending)) .put(QUALIFIER_SORT, componentQualifierOrdering(isAscending)) .put(PATH_SORT, componentPathOrdering(isAscending)) .put(METRIC_SORT, metricValueOrdering(wsRequest, metrics, measuresByComponentUuidAndMetric)) .put(METRIC_PERIOD_SORT, metricPeriodOrdering(wsRequest, metrics, measuresByComponentUuidAndMetric)) .build(); String firstSortParameter = sortParameters.get(0); Ordering<ComponentDto> primaryOrdering = orderingsBySortField.get(firstSortParameter); if (sortParameters.size() > 1) { for (int i = 1; i < sortParameters.size(); i++) { String secondarySortParameter = sortParameters.get(i); Ordering<ComponentDto> secondaryOrdering = orderingsBySortField.get(secondarySortParameter); primaryOrdering = primaryOrdering.compound(secondaryOrdering); } } primaryOrdering = primaryOrdering.compound(componentNameOrdering(true)); return primaryOrdering.immutableSortedCopy(components); }
public void testCompound_instance() { Comparator<String> comparator = byCharAt(1).compound(byCharAt(0)); Helpers.testComparator( comparator, ImmutableList.of("red", "yellow", "violet", "blue", "indigo", "green", "orange")); }
@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)); } for (T t : scenario.strictlyOrderedList) { composites.add(new Composite<T>(t, 2)); } Ordering<Composite<T>> ordering = Ordering.natural() .compound(scenario.ordering.onResultOf(Composite.<T>getValueFunction())); return new Scenario<Composite<T>>(ordering, composites, new Composite[0]); } },
@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]); } },
.compound(Ordering.<DataSegment>natural()) .reverse();
public void testCompound_static() { Comparator<String> comparator = Ordering.compound( ImmutableList.of( byCharAt(0), byCharAt(1), byCharAt(2), byCharAt(3), byCharAt(4), byCharAt(5))); Helpers.testComparator( comparator, ImmutableList.of( "applesauce", "apricot", "artichoke", "banality", "banana", "banquet", "tangelo", "tangerine")); reserializeAndAssert(comparator); }
assertThat(config.getOverviewDocument()).isEqualTo("overview"); assertThat(config.getParameterOrderBy()).isEqualTo(OrderBy.NATURAL); assertThat(config.getParameterOrdering()).isEqualTo(Swagger2MarkupConfigBuilder.PARAMETER_IN_NATURAL_ORDERING.compound(Swagger2MarkupConfigBuilder.PARAMETER_NAME_NATURAL_ORDERING)); assertThat(config.getPathsDocument()).isEqualTo("paths"); assertThat(config.getPathsGroupedBy()).isEqualTo(GroupBy.AS_IS);
assertThat(config.getMarkupLanguage()).isEqualTo(MarkupLanguage.MARKDOWN); assertThat(config.getOperationOrderBy()).isEqualTo(OrderBy.NATURAL); assertThat(config.getOperationOrdering()).isEqualTo(Swagger2MarkupConfigBuilder.OPERATION_PATH_NATURAL_ORDERING.compound(Swagger2MarkupConfigBuilder.OPERATION_METHOD_NATURAL_ORDERING)); assertThat(config.getOutputLanguage()).isEqualTo(Language.RU); assertThat(config.getOverviewDocument()).isEqualTo("overviewTest");
/** * Get the sort order as an ordering. * @return An ordering representing the {@linkplain #getSortKeys() sort order} of this query. */ public Ordering<Entity> getOrdering() { Ordering<Entity> ord = null; for (SortKey k: sortKeys) { if (ord == null) { ord = k.ordering(); } else { ord = ord.compound(k.ordering()); } } return ord; }
/** * Builds a comparator from the list of columns in ORDER BY clause. * @param orderByExpressions the columns in ORDER BY clause. * @return the comparator built from the list of columns in ORDER BY clause. */ // ImmutableBytesWritable.Comparator doesn't implement generics @SuppressWarnings("unchecked") private static Comparator<ResultEntry> buildComparator(List<OrderByExpression> orderByExpressions) { Ordering<ResultEntry> ordering = null; int pos = 0; for (OrderByExpression col : orderByExpressions) { Ordering<ImmutableBytesWritable> o = Ordering.from(new ImmutableBytesWritable.Comparator()); if(!col.isAscending()) o = o.reverse(); o = col.isNullsLast() ? o.nullsLast() : o.nullsFirst(); Ordering<ResultEntry> entryOrdering = o.onResultOf(new NthKey(pos++)); ordering = ordering == null ? entryOrdering : ordering.compound(entryOrdering); } return ordering; }
/** * Builds a comparator from the list of columns in ORDER BY clause. * @param orderByExpressions the columns in ORDER BY clause. * @return the comparator built from the list of columns in ORDER BY clause. */ // ImmutableBytesWritable.Comparator doesn't implement generics @SuppressWarnings("unchecked") private static Comparator<ResultEntry> buildComparator(List<OrderByExpression> orderByExpressions) { Ordering<ResultEntry> ordering = null; int pos = 0; for (OrderByExpression col : orderByExpressions) { Expression e = col.getExpression(); Comparator<ImmutableBytesWritable> comparator = e.getSortOrder() == SortOrder.DESC && !e.getDataType().isFixedWidth() ? buildDescVarLengthComparator() : new ImmutableBytesWritable.Comparator(); Ordering<ImmutableBytesWritable> o = Ordering.from(comparator); if(!col.isAscending()) o = o.reverse(); o = col.isNullsLast() ? o.nullsLast() : o.nullsFirst(); Ordering<ResultEntry> entryOrdering = o.onResultOf(new NthKey(pos++)); ordering = ordering == null ? entryOrdering : ordering.compound(entryOrdering); } return ordering; }
protected Ordering<Hardware> hardwareSorter() { Ordering<Hardware> hardwareOrdering = DEFAULT_SIZE_ORDERING; if (!biggest) hardwareOrdering = hardwareOrdering.reverse(); if (fastest) hardwareOrdering = Ordering.compound(ImmutableList.of(BY_CORES_ORDERING, hardwareOrdering)); hardwareOrdering = Ordering.compound(ImmutableList.of(NOT_DEPRECATED_ORDERING, hardwareOrdering)); return hardwareOrdering; }
protected Ordering<Hardware> hardwareSorter() { Ordering<Hardware> hardwareOrdering = DEFAULT_SIZE_ORDERING; if (!biggest) hardwareOrdering = hardwareOrdering.reverse(); if (fastest) hardwareOrdering = Ordering.compound(ImmutableList.of(BY_CORES_ORDERING, hardwareOrdering)); return hardwareOrdering; }
private ValueComparableMap(Ordering<? super V> partialValueOrdering, HashMap<K, V> valueMap) { super(partialValueOrdering // Apply the value ordering .onResultOf(Functions.forMap(valueMap)) // On the result of // getting the value // for the key from // the map .compound(Ordering.natural())); // as well as ensuring that // the keys don't get // clobbered this.valueMap = valueMap; }
private Comparator<Row> comparator() { if (rel.getCollation().getFieldCollations().size() == 1) { return comparator(rel.getCollation().getFieldCollations().get(0)); } return Ordering.compound( Iterables.transform(rel.getCollation().getFieldCollations(), this::comparator)); }