Example usage for com.google.common.collect Ordering natural

Introduction

In this page you can find the example usage for com.google.common.collect Ordering natural.

Prototype

@GwtCompatible(serializable = true)
@SuppressWarnings("unchecked") 
public static <C extends Comparable> Ordering<C> natural()

Source Link

Document

Returns a serializable ordering that uses the natural order of the values.

Usage

From source file:io.druid.query.aggregation.atomcube.AtomCubeTopNSizePostAggregator.java

@Override
public Object compute(final Map<String, Object> cardinalities) {
    List<Integer> cardinalityList = Lists.newArrayList();
    for (String field : fields) {
        cardinalityList.add((Integer) cardinalities.get(field));
    }/*from w ww.  ja  va 2 s.  c  o  m*/
    if (cardinalityList.size() > 1) {
        Collections.sort(cardinalityList, Ordering.natural());
    }
    int length = cardinalityList.size() > topN ? topN : cardinalityList.size();
    return cardinalityList.subList(0, length);
}

From source file:org.mayocat.store.memory.AbstractPositionedEntityMemoryStore.java

protected List<T> all() {
    return FluentIterable
            .from(Ordering.natural().onResultOf(positionOrdering)
                    .sortedCopy(FluentIterable.from(store.findAll(0, 0))))
            .transform(positionedToEntity).toList();
}

From source file:com.metamx.druid.merger.common.task.AppendTask.java

@Override
public File merge(final Map<DataSegment, File> segments, final File outDir) throws Exception {
    VersionedIntervalTimeline<String, DataSegment> timeline = new VersionedIntervalTimeline<String, DataSegment>(
            Ordering.natural().nullsFirst());

    for (DataSegment segment : segments.keySet()) {
        timeline.add(segment.getInterval(), segment.getVersion(), segment.getShardSpec().createChunk(segment));
    }//from   w  w w.j  av  a  2 s  .  c o m

    final List<SegmentToMergeHolder> segmentsToMerge = Lists.transform(
            timeline.lookup(new Interval("1000-01-01/3000-01-01")),
            new Function<TimelineObjectHolder<String, DataSegment>, SegmentToMergeHolder>() {
                @Override
                public SegmentToMergeHolder apply(TimelineObjectHolder<String, DataSegment> input) {
                    final DataSegment segment = input.getObject().getChunk(0).getObject();
                    final File file = Preconditions.checkNotNull(segments.get(segment), "File for segment %s",
                            segment.getIdentifier());

                    return new SegmentToMergeHolder(segment, input.getInterval(), file);
                }
            });

    List<IndexableAdapter> adapters = Lists.newArrayList();

    for (final SegmentToMergeHolder holder : segmentsToMerge) {
        adapters.add(new RowboatFilteringIndexAdapter(
                new QueryableIndexIndexableAdapter(IndexIO.loadIndex(holder.getFile())),
                new Predicate<Rowboat>() {
                    @Override
                    public boolean apply(@Nullable Rowboat input) {
                        return holder.getInterval().contains(input.getTimestamp());
                    }
                }));
    }

    return IndexMerger.append(adapters, outDir);
}

From source file:org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils.java

public static void checkAvailableActionsAreExpected(JetFile file,
        Collection<IntentionAction> availableActions) {
    List<String> validActions = Ordering.natural().sortedCopy(Lists
            .newArrayList(InTextDirectivesUtils.findLinesWithPrefixesRemoved(file.getText(), "// ACTION:")));

    Collection<String> actualActions = Ordering.natural().sortedCopy(Lists
            .newArrayList(Collections2.transform(availableActions, new Function<IntentionAction, String>() {
                @Override//ww  w.ja  v  a  2  s  . c  om
                public String apply(@Nullable IntentionAction input) {
                    assert input != null;
                    return input.getText();
                }
            })));

    UsefulTestCase.assertOrderedEquals(
            "Some unexpected actions available at current position: %s. Use // ACTION: directive",
            filterOutIrrelevantActions(actualActions), filterOutIrrelevantActions(validActions));
}

From source file:eu.interedition.collatex.util.ParallelSegmentationApparatus.java

public static void generate(VariantGraphRanking ranking, GeneratorCallback callback) {

    callback.start();/*  w  w  w  . j  a  v  a  2 s.c o m*/

    final Set<Witness> allWitnesses = ranking.witnesses();
    for (Iterator<Map.Entry<Integer, Collection<VariantGraph.Vertex>>> rowIt = ranking.getByRank().asMap()
            .entrySet().iterator(); rowIt.hasNext();) {
        final Map.Entry<Integer, Collection<VariantGraph.Vertex>> row = rowIt.next();
        final int rank = row.getKey();
        final Collection<VariantGraph.Vertex> vertices = row.getValue();

        if (vertices.size() == 1 && Iterables.getOnlyElement(vertices).tokens().isEmpty()) {
            // skip start and end vertex
            continue;
        }

        // spreading vertices with same rank according to their registered transpositions
        final Multimap<Integer, VariantGraph.Vertex> verticesByTranspositionRank = HashMultimap.create();
        for (VariantGraph.Vertex v : vertices) {
            int transpositionRank = 0;
            for (VariantGraph.Transposition transposition : v.transpositions()) {
                for (VariantGraph.Vertex tv : transposition) {
                    transpositionRank += (ranking.apply(tv).intValue() - rank);
                }
            }
            verticesByTranspositionRank.put(transpositionRank, v);
        }

        // render segments
        for (Iterator<Integer> transpositionRankIt = Ordering.natural()
                .immutableSortedCopy(verticesByTranspositionRank.keySet()).iterator(); transpositionRankIt
                        .hasNext();) {
            final Multimap<Witness, Token> tokensByWitness = HashMultimap.create();
            for (VariantGraph.Vertex v : verticesByTranspositionRank.get(transpositionRankIt.next())) {
                for (Token token : v.tokens()) {
                    tokensByWitness.put(token.getWitness(), token);
                }
            }

            final SortedMap<Witness, Iterable<Token>> cellContents = Maps.newTreeMap(Witness.SIGIL_COMPARATOR);
            for (Witness witness : allWitnesses) {
                cellContents.put(witness,
                        tokensByWitness.containsKey(witness)
                                ? Iterables.unmodifiableIterable(tokensByWitness.get(witness))
                                : Collections.<Token>emptySet());
            }

            callback.segment(cellContents);
        }
    }

    callback.end();
}

From source file:org.sonar.server.authentication.IdentityProviderRepository.java

public List<IdentityProvider> getAllEnabledAndSorted() {
    return from(providersByKey.values()).filter(IsEnabledFilter.INSTANCE)
            .toSortedList(Ordering.natural().onResultOf(ToName.INSTANCE));
}

From source file:com.google.devtools.build.lib.skylarkdebug.server.DebuggerSerialization.java

private static ImmutableList<Value> getChildren(ClassObject classObject) {
    ImmutableList.Builder<Value> builder = ImmutableList.builder();
    ImmutableList<String> keys;
    try {//w w w  . j  av  a2 s  . c o  m
        keys = Ordering.natural().immutableSortedCopy(classObject.getFieldNames());
    } catch (EvalException e) {
        return ImmutableList.of(errorValue("Error retrieving field names: " + e.getMessage()));
    }
    for (String key : keys) {
        Object value;
        try {
            value = classObject.getValue(key);
        } catch (EvalException e) {
            return ImmutableList.of(errorValue(
                    String.format("Error retrieving value for field '%s': %s", key, e.getMessage())));
        }
        if (value != null) {
            builder.add(getValueProto(key, value));
        }
    }
    return builder.build();
}

From source file:com.googlesource.gerrit.plugins.findowners.Util.java

static SortedMap<String, List<String>> makeSortedMap(Map<String, Set<String>> map) {
    SortedMap<String, List<String>> result = new TreeMap<>();
    for (String key : Ordering.natural().sortedCopy(map.keySet())) {
        result.put(key, Ordering.natural().sortedCopy(map.get(key)));
    }//  w  w  w . j a  va2s .c o m
    return result;
}

From source file:com.facebook.buck.util.MoreCollectors.java

/**
 * Returns a {@code Collector} that builds an {@code ImmutableSortedSet}.
 *
 * This {@code Collector} behaves similar to:
 * {@code Collectors.collectingAndThen(// w w w . ja  v a 2s. c  om
 *    Collectors.toList(), list -> ImmutableSortedSet.copyOf(comparator, list))
 *  }
 *  but without building the intermediate list.
 *
 * @param <T> the type of the input elements
 * @return a {@code Collector} that builds an {@code ImmutableSortedSet}.
 */
public static <T extends Comparable<T>> Collector<T, ?, ImmutableSortedSet<T>> toImmutableSortedSet() {
    return Collector.of(() -> new ImmutableSortedSet.Builder<T>(Ordering.natural()),
            ImmutableSortedSet.Builder::add, (left, right) -> left.addAll(right.build()),
            ImmutableSortedSet.Builder::build);
}

From source file:com.netflix.priam.resources.PriamInstanceResource.java

/**
 * Get the list of all priam instances/* ww  w.j  a v a2s . c om*/
 *
 * @return the list of all priam instances
 */
@GET
public String getInstances() {
    StringBuilder response = new StringBuilder();
    List<PriamInstance> nodes = instanceRegistry.getAllIds(cassandraConfiguration.getClusterName());
    for (PriamInstance node : Ordering.natural().sortedCopy(nodes)) {
        response.append(node.toString());
        response.append("\n");
    }
    return response.toString();
}