SegmentsCostCache(ArrayList<Bucket> sortedBuckets) { this.sortedBuckets = Preconditions.checkNotNull(sortedBuckets, "buckets should not be null"); this.intervals = sortedBuckets.stream().map(Bucket::getInterval).collect(Collectors.toCollection(ArrayList::new)); Preconditions.checkArgument( BUCKET_ORDERING.isOrdered(sortedBuckets), "buckets must be ordered by interval" ); }
Bucket(Interval interval, ArrayList<DataSegment> sortedSegments, double[] leftSum, double[] rightSum) { this.interval = Preconditions.checkNotNull(interval, "interval"); this.sortedSegments = Preconditions.checkNotNull(sortedSegments, "sortedSegments"); this.leftSum = Preconditions.checkNotNull(leftSum, "leftSum"); this.rightSum = Preconditions.checkNotNull(rightSum, "rightSum"); Preconditions.checkArgument(sortedSegments.size() == leftSum.length && sortedSegments.size() == rightSum.length); Preconditions.checkArgument(SEGMENT_ORDERING.isOrdered(sortedSegments)); this.calculationInterval = new Interval( interval.getStart().minus(LIFE_THRESHOLD), interval.getEnd().plus(LIFE_THRESHOLD) ); }
comparator = (Comparator) Comparator.naturalOrder(); assertTrue(Ordering.from(comparator).isOrdered(resultsForStrategy));
public void testIsOrdered() { assertFalse(numberOrdering.isOrdered(asList(5, 3, 0, 9))); assertFalse(numberOrdering.isOrdered(asList(0, 5, 3, 9))); assertTrue(numberOrdering.isOrdered(asList(0, 3, 5, 9))); assertTrue(numberOrdering.isOrdered(asList(0, 0, 3, 3))); assertTrue(numberOrdering.isOrdered(asList(0, 3))); assertTrue(numberOrdering.isOrdered(Collections.singleton(1))); assertTrue(numberOrdering.isOrdered(Collections.<Integer>emptyList())); }
void testIsOrdered() { assertTrue(ordering.isOrdered(strictlyOrderedList)); assertTrue(ordering.isStrictlyOrdered(strictlyOrderedList)); }
checkArgument(Ordering.natural().isOrdered(quantiles), "quantiles must be sorted in increasing order"); for (double quantile : quantiles) { checkArgument(quantile >= 0 && quantile <= 1, "quantile must be between [0,1]");
public void testBulkGetReturnsSorted() { for (Striped<?> striped : allImplementations()) { Map<Object, Integer> indexByLock = Maps.newHashMap(); for (int i = 0; i < striped.size(); i++) { indexByLock.put(striped.getAt(i), i); } // ensure that bulkGet returns locks in monotonically increasing order for (int objectsNum = 1; objectsNum <= striped.size() * 2; objectsNum++) { Set<Object> objects = Sets.newHashSetWithExpectedSize(objectsNum); for (int i = 0; i < objectsNum; i++) { objects.add(new Object()); } Iterable<?> locks = striped.bulkGet(objects); assertTrue(Ordering.natural().onResultOf(Functions.forMap(indexByLock)).isOrdered(locks)); // check idempotency Iterable<?> locks2 = striped.bulkGet(objects); assertEquals(Lists.newArrayList(locks), Lists.newArrayList(locks2)); } } }
if (!Ordering.natural().isOrdered(mods)) { Collections.sort(mods); StringBuilder replacement = new StringBuilder();
@Test public void testVLongDimEncPreserveOrder() { for (int i = 1; i <= successValue.size(); i++) { IntegerDimEnc enc = new IntegerDimEnc(i); List<ByteArray> encodedValues = Lists.newArrayList(); for (long value : successValue.get(i - 1)) { encodedValues.add(encode(enc, value)); } encodedValues.add(encode(enc, null)); assertTrue(Ordering.from(new DefaultGTComparator()).isOrdered(encodedValues)); } }
public List<Bucket> getHistogram(List<Long> bucketUpperBounds) { checkArgument(Ordering.natural().isOrdered(bucketUpperBounds), "buckets must be sorted in increasing order");
@Test public void testFixedLengthHexDimEncPreserveOrder() { FixedLenHexDimEnc enc = new FixedLenHexDimEnc(4); List<ByteArray> encodedValues = Lists.newArrayList(); encodedValues.add(encode(enc, "0000")); encodedValues.add(encode(enc, "0001")); encodedValues.add(encode(enc, "FFF0")); encodedValues.add(encode(enc, null)); assertTrue(Ordering.from(new DefaultGTComparator()).isOrdered(encodedValues)); }
@Test public void testOneMoreByteVLongDimEncPreserveOrder() { // TODO: better test OneMoreByteVLongDimEnc enc = new OneMoreByteVLongDimEnc(2); List<ByteArray> encodedValues = Lists.newArrayList(); encodedValues.add(encode(enc, -32768L)); encodedValues.add(encode(enc, -10000L)); encodedValues.add(encode(enc, -100L)); encodedValues.add(encode(enc, 0L)); encodedValues.add(encode(enc, 100L)); encodedValues.add(encode(enc, 10000L)); encodedValues.add(encode(enc, 32767L)); encodedValues.add(encode(enc, null)); assertTrue(Ordering.from(new DefaultGTComparator()).isOrdered(encodedValues)); }
checkArgument(Ordering.natural().isOrdered(quantiles), "quantiles must be sorted in increasing order"); for (double quantile : quantiles) {
private static void checkExamplesOrdered( @Nullable Class<? extends Comparator<?>> comparator, IntFunction<?> exampleGenerator) { if (comparator == null) { List<Comparable<?>> comparables = IntStream .range(0, 7) .mapToObj(exampleGenerator) .map(v -> (Comparable<?>) v) .collect(toList()); checkState(Ordering.natural().isOrdered(comparables), "Examples must be in natural order (got %s)", comparables); } else { try { @SuppressWarnings("rawtypes") Ordering ordering = Ordering.from(comparator.newInstance()); List<?> comparables = range(0, 7).mapToObj(exampleGenerator).collect(toList()); @SuppressWarnings("unchecked") boolean isOrdered = ordering.isOrdered(comparables); checkState(isOrdered, "Examples must be in natural order (got %s)", comparables); } catch (ReflectiveOperationException e) { throw new RuntimeException(e); } } } }
public synchronized List<Bucket> getHistogram(List<Long> bucketUpperBounds) { checkArgument( Ordering.natural().isOrdered(bucketUpperBounds), "buckets must be sorted in increasing order" );
public OffsetLookup(final ImmutableList<OffsetCue> offsetCueList) { assert offsetCueList != null : "Offset cue list can't be null."; assert ORDER_BY_ABSOLUTE.isOrdered(offsetCueList) : "Offset cue list should be sorted by absolute offset."; // For now the creation of offsetCueList guarantees the ordering of the // list, so we needn't do a sorted immutable copy. this.offsetCueList = offsetCueList; }
private void reportIfOutOfOrder(List<Node> requiresOrProvides, DiagnosticType warning) { if (!alphabetical.isOrdered(requiresOrProvides)) { StringBuilder correctOrder = new StringBuilder(); for (Node n : alphabetical.sortedCopy(requiresOrProvides)) { correctOrder.append(compiler.toSource(n)); } compiler.report( JSError.make(requiresOrProvides.get(0), warning, correctOrder.toString())); } }
private RelDistributionImpl(Type type, ImmutableIntList keys) { this.type = Objects.requireNonNull(type); this.keys = ImmutableIntList.copyOf(keys); assert type != Type.HASH_DISTRIBUTED || keys.size() < 2 || Ordering.natural().isOrdered(keys) : "key columns of hash distribution must be in order"; assert type == Type.HASH_DISTRIBUTED || type == Type.RANDOM_DISTRIBUTED || keys.isEmpty(); }
/** Creates a hash distribution. */ public static RelDistribution hash(Collection<? extends Number> numbers) { ImmutableIntList list = ImmutableIntList.copyOf(numbers); if (numbers.size() > 1 && !Ordering.natural().isOrdered(list)) { list = ImmutableIntList.copyOf(Ordering.natural().sortedCopy(list)); } RelDistributionImpl trait = new RelDistributionImpl(RelDistribution.Type.HASH_DISTRIBUTED, list); return RelDistributionTraitDef.INSTANCE.canonize(trait); }
public void testSearchOrderByCreatedDescWorks() throws Exception { for (int i = 0; i < 10; i++) { WaveletName name = WaveletName.of(WaveId.of(DOMAIN, String.valueOf(i)), WAVELET_ID); submitDeltaToNewWavelet(name, USER1, addParticipantToWavelet(USER1, name)); } SearchResult results = searchProvider.search(USER1, "in:inbox orderby:createddesc", 0, 10); Ordering<SearchResult.Digest> descOrdering = Ordering.from(DESC_CREATED_COMPARATOR); assertTrue(descOrdering.isOrdered(results.getDigests())); }