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

Introduction

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

Prototype

@GwtCompatible(serializable = true)
@Deprecated
public static <T> Ordering<T> from(Ordering<T> ordering)

Source Link

Document

Simply returns its argument.

Usage

From source file:com.cloudera.oryx.app.serving.als.MostPopularItems.java

static List<IDCount> mapTopCountsToIDCounts(Map<String, Integer> counts, int howMany, int offset,
        final Rescorer rescorer) {
    Iterable<Pair<String, Integer>> countPairs = Iterables.transform(counts.entrySet(),
            new Function<Map.Entry<String, Integer>, Pair<String, Integer>>() {
                @Override/*from   w ww  .j a  v a 2s. com*/
                public Pair<String, Integer> apply(Map.Entry<String, Integer> input) {
                    return new Pair<>(input.getKey(), input.getValue());
                }
            });

    if (rescorer != null) {
        countPairs = Iterables.filter(countPairs, new Predicate<Pair<String, Integer>>() {
            @Override
            public boolean apply(Pair<String, Integer> input) {
                return !rescorer.isFiltered(input.getFirst());
            }
        });
    }

    List<Pair<String, Integer>> allTopCountPairs = Ordering.from(PairComparators.<Integer>bySecond())
            .greatestOf(countPairs, howMany + offset);
    List<Pair<String, Integer>> topCountPairs = selectedSublist(allTopCountPairs, howMany, offset);

    return Lists.transform(topCountPairs, new Function<Pair<String, Integer>, IDCount>() {
        @Override
        public IDCount apply(Pair<String, Integer> idCount) {
            return new IDCount(idCount.getFirst(), idCount.getSecond());
        }
    });
}

From source file:com.cognifide.aet.cleaner.processors.filters.SuiteRemoveCondition.java

private Long getMinKeepVersion(final Collection<Suite> suiteRunVersions, CleanerContext cleanerContext) {
    Long minVersionToKeep;//from w w  w.j  av a  2  s .  com
    int keepNVersions = getKeepNVersionsOrSecureToLastVersion(cleanerContext);

    if (suiteRunVersions.size() > keepNVersions) {
        final List<Suite> suites = Ordering.from(COMPARE_SUITES_BY_VERSION_DESC).sortedCopy(suiteRunVersions);
        minVersionToKeep = suites.get(keepNVersions - 1).getVersion();
    } else {
        final List<Suite> suites = Ordering.from(COMPARE_SUITES_BY_VERSION_ASC).leastOf(suiteRunVersions, 1);
        minVersionToKeep = suites.iterator().next().getVersion();
    }
    return minVersionToKeep;
}

From source file:com.esofthead.mycollab.module.project.ui.components.TimeTrackingProjectOrderComponent.java

@Override
protected Ordering<SimpleItemTimeLogging> sortEntries() {
    return Ordering.from(new ProjectComparator()).compound(new DateComparator()).compound(new UserComparator());
}

From source file:com.indeed.lsmtree.core.ReverseGeneration.java

@Override
public Comparator<K> getComparator() {
    return Ordering.from(wrapped.getComparator()).reverse();
}

From source file:ch.ifocusit.livingdoc.plugin.publish.model.Page.java

@Override
public int compareTo(final Page o) {
    return Ordering.from(Comparator.comparing(Page::getFileName)).compare(this, o);
}

From source file:edu.sabanciuniv.sentilab.sare.models.setcover.DocumentSetCover.java

private Pair<List<SetCoverDocument>, List<SetCoverDocument>> splitByCoverage(double weightCoverage) {
    List<SetCoverDocument> covered = Lists.newArrayList();
    List<SetCoverDocument> uncovered = Lists.newArrayList();
    List<SetCoverDocument> setCoverDocuments = Collections
            .synchronizedList(Lists.newArrayList(this.getAllDocuments()));

    double totalWeight = this.getTotalWeight();
    double accumulatedWeight = 0;

    // sort set cover.
    Iterator<SetCoverDocument> iterator = Ordering.from(new Comparator<SetCoverDocument>() {
        @Override//from   ww w  .  j a  v  a2  s . com
        public int compare(SetCoverDocument o1, SetCoverDocument o2) {
            return (int) ((o2.getWeight() - o1.getWeight()) * 100);
        }
    }).immutableSortedCopy(setCoverDocuments).iterator();

    // get all the useful ones.
    while (iterator.hasNext()) {
        if (accumulatedWeight >= weightCoverage * totalWeight) {
            break;
        }

        SetCoverDocument document = iterator.next();
        accumulatedWeight += document.getWeight();
        covered.add(document);
    }

    while (iterator.hasNext()) {
        uncovered.add(iterator.next());
    }

    return new ImmutablePair<List<SetCoverDocument>, List<SetCoverDocument>>(covered, uncovered);
}

From source file:com.spotify.heroic.metric.FetchData.java

@Deprecated
public static Collector<FetchData, FetchData> collect(final QueryTrace.Identifier what) {
    final Collector<Result, Result> resultCollector = collectResult(what);

    return fetchDataCollection -> {
        final ImmutableList.Builder<Long> times = ImmutableList.builder();
        final Map<MetricType, ImmutableList.Builder<Metric>> fetchGroups = new HashMap<>();
        final ImmutableList.Builder<Result> results = ImmutableList.builder();

        for (final FetchData fetch : fetchDataCollection) {
            times.addAll(fetch.times);/*from   w  ww. j  a v  a2s .  co  m*/
            results.add(fetch.result);

            for (final MetricCollection g : fetch.groups) {
                ImmutableList.Builder<Metric> data = fetchGroups.get(g.getType());

                if (data == null) {
                    data = new ImmutableList.Builder<>();
                    fetchGroups.put(g.getType(), data);
                }

                data.addAll(g.data);
            }
        }

        final List<MetricCollection> groups = fetchGroups.entrySet().stream()
                .map((e) -> MetricCollection.build(e.getKey(),
                        Ordering.from(Metric.comparator()).immutableSortedCopy(e.getValue().build())))
                .collect(Collectors.toList());

        return new FetchData(resultCollector.collect(results.build()), times.build(), groups);
    };
}

From source file:springfox.documentation.spi.service.contexts.Orderings.java

public static Ordering<RequestHandler> byPatternsCondition() {
    return Ordering.from(new Comparator<RequestHandler>() {
        @Override//from   w ww .  ja v  a 2  s .  c o m
        public int compare(RequestHandler first, RequestHandler second) {
            return patternsCondition(first).toString().compareTo(patternsCondition(second).toString());
        }
    });
}

From source file:com.cloudera.oryx.ml.serving.als.Because.java

@GET
@Path("{userID}/{itemID}")
@Produces({ CSVMessageBodyWriter.TEXT_CSV, MediaType.APPLICATION_JSON })
public List<IDValue> get(@PathParam("userID") String userID, @PathParam("itemID") String itemID,
        @DefaultValue("10") @QueryParam("howMany") int howMany,
        @DefaultValue("0") @QueryParam("offset") int offset) throws OryxServingException {

    check(howMany > 0, "howMany must be positive");
    check(offset >= 0, "offset must be non-negative");

    ALSServingModel model = getALSServingModel();
    float[] itemVector = model.getItemVector(itemID);
    checkExists(itemVector != null, itemID);
    List<Pair<String, float[]>> knownItemVectors = model.getKnownItemVectorsForUser(userID);
    checkExists(knownItemVectors != null, userID);

    Iterable<Pair<String, Double>> idSimilarities = Iterables.transform(knownItemVectors,
            new CosineSimilarityFunction(itemVector));

    Ordering<Pair<?, Double>> ordering = Ordering.from(PairComparators.<Double>bySecond());
    return toIDValueResponse(ordering.greatestOf(idSimilarities, howMany + offset), howMany, offset);
}

From source file:com.cloudera.oryx.app.serving.als.Because.java

@GET
@Path("{userID}/{itemID}")
@Produces({ MediaType.TEXT_PLAIN, CSVMessageBodyWriter.TEXT_CSV, MediaType.APPLICATION_JSON })
public List<IDValue> get(@PathParam("userID") String userID, @PathParam("itemID") String itemID,
        @DefaultValue("10") @QueryParam("howMany") int howMany,
        @DefaultValue("0") @QueryParam("offset") int offset) throws OryxServingException {

    check(howMany > 0, "howMany must be positive");
    check(offset >= 0, "offset must be non-negative");

    ALSServingModel model = getALSServingModel();
    float[] itemVector = model.getItemVector(itemID);
    checkExists(itemVector != null, itemID);
    List<Pair<String, float[]>> knownItemVectors = model.getKnownItemVectorsForUser(userID);
    checkExists(knownItemVectors != null, userID);

    Iterable<Pair<String, Double>> idSimilarities = Iterables.transform(knownItemVectors,
            new CosineSimilarityFunction(itemVector));

    Ordering<Pair<?, Double>> ordering = Ordering.from(PairComparators.<Double>bySecond());
    return toIDValueResponse(ordering.greatestOf(idSimilarities, howMany + offset), howMany, offset);
}