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

List of usage examples for com.google.common.collect Ordering natural

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. Ordering
  6. 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:com.sun.tools.hat.internal.server.RootsQuery.java

@Override
public void run() {
    long id = parseHex(query);
    JavaHeapObject target = snapshot.findThing(id);
    if (target == null) {
        startHtml("Object not found for rootset");
        error("object not found");
        endHtml();/*from   w  w  w  .  j  a v a2  s  .  c  o m*/
        return;
    }
    if (includeWeak) {
        startHtml("Rootset references to " + target + " (includes weak refs)");
    } else {
        startHtml("Rootset references to " + target + " (excludes weak refs)");
    }
    out.flush();

    out.print("<h1>References to ");
    printThing(target);
    out.println("</h1>");
    // More interesting values are *higher*
    Multimap<Integer, ReferenceChain> refs = Multimaps.index(snapshot.rootsetReferencesTo(target, includeWeak),
            chain -> chain.getObj().getRoot().getType());
    refs.asMap().entrySet().stream().sorted(Ordering.natural().reverse().onResultOf(entry -> entry.getKey()))
            .forEach(entry -> {
                out.print("<h2>");
                print(Root.getTypeName(entry.getKey()) + " References");
                out.println("</h2>");
                entry.getValue().stream().sorted(Ordering.natural().onResultOf(ReferenceChain::getDepth))
                        .forEach(ref -> {
                            Root root = ref.getObj().getRoot();
                            out.print("<h3>");
                            printRoot(root);
                            if (root.getReferer() != null) {
                                out.print("<small> (from ");
                                printThingAnchorTag(root.getReferer().getId());
                                print(root.getReferer().toString());
                                out.print(")</a></small>");

                            }
                            out.print(" :</h3>");
                            while (ref != null) {
                                ReferenceChain next = ref.getNext();
                                JavaHeapObject obj = ref.getObj();
                                print("--> ");
                                printThing(obj);
                                if (next != null) {
                                    print(" (" + obj.describeReferenceTo(next.getObj(), snapshot) + ":)");
                                }
                                out.println("<br>");
                                ref = next;
                            }
                        });
            });

    out.println("<h2>Other queries</h2>");

    if (includeWeak) {
        printAnchorStart();
        out.print("roots/");
        printHex(id);
        out.print("\">");
        out.println("Exclude weak refs</a><br>");
        endHtml();
    }

    if (!includeWeak) {
        printAnchorStart();
        out.print("allRoots/");
        printHex(id);
        out.print("\">");
        out.println("Include weak refs</a><br>");
    }
}

From source file:org.gradle.plugins.ide.internal.tooling.BuildInvocationsBuilder.java

@SuppressWarnings("StringEquality")
public DefaultBuildInvocations buildAll(String modelName, Project project) {
    if (!canBuild(modelName)) {
        throw new GradleException("Unknown model name " + modelName);
    }/*w ww  .j  a v a2  s  . c  o m*/

    // construct task selectors
    List<LaunchableGradleTaskSelector> selectors = Lists.newArrayList();
    Map<String, LaunchableGradleTaskSelector> selectorsByName = Maps.newTreeMap(Ordering.natural());
    Set<String> visibleTasks = Sets.newLinkedHashSet();
    findTasks(project, selectorsByName, visibleTasks);
    for (String selectorName : selectorsByName.keySet()) {
        LaunchableGradleTaskSelector selector = selectorsByName.get(selectorName);
        selectors.add(selector.setName(selectorName).setTaskName(selectorName).setProjectPath(project.getPath())
                .setDisplayName(String.format("%s in %s and subprojects.", selectorName, project.toString()))
                .setPublic(visibleTasks.contains(selectorName)));
    }

    // construct project tasks
    List<LaunchableGradleTask> projectTasks = tasks(project);

    // construct build invocations from task selectors and project tasks
    return new DefaultBuildInvocations().setSelectors(selectors).setTasks(projectTasks);
}

From source file:de.tuberlin.uebb.jdae.transformation.Reduction.java

public Reduction(final Collection<Equation> equations) {
    final ImmutableList.Builder<GlobalEquation> be = ImmutableList.builder();

    this.names = Maps.newTreeMap();

    final Map<Unknown, Integer> layout = Maps.newTreeMap();

    final TransitiveRelation<Unknown> equivalent = Relations.newTransitiveRelation();

    for (Equation eq : equations) {
        for (Unknown unknown : eq.unknowns()) {
            final Unknown base = unknown.base();
            final Integer order = layout.get(base);
            if (order == null || (unknown.der > order))
                layout.put(base, unknown.der);
        }// w ww  .j  a va2  s  .  c  o  m

        if (eq instanceof Equality) {
            final Unknown l = ((Equality) eq).lhs;
            final Unknown r = ((Equality) eq).rhs;
            Unknown min = Ordering.natural().min(l, r);
            Unknown max = Ordering.natural().max(l, r);

            if (min.der == 0) {
                equivalent.relate(min, max);
            }
        }
    }

    final Navigator<Unknown> direct = equivalent.direct();
    final Map<Unknown, Unknown> repres = Maps.newTreeMap();

    for (Map.Entry<Unknown, Integer> entry : layout.entrySet()) {
        final Unknown base = entry.getKey();
        final int max = entry.getValue();
        final Unknown repr = Collections.max(Navigators.closure(direct, base), Ordering.natural());

        for (int i = 0; i <= max; i++) {
            repres.put(base.der(i), repr.der(i));
        }
    }

    final Function<Unknown, GlobalVariable> pack_dense = new Function<Unknown, GlobalVariable>() {
        final Map<Integer, Integer> mem = Maps.newTreeMap();

        public GlobalVariable apply(Unknown u) {
            if (!mem.containsKey(u.nr)) {
                mem.put(u.nr, (mem.size() + 1));
                names.put(mem.get(u.nr), u.name);
            }
            return new GlobalVariable(u.name, mem.get(u.nr), u.der);
        }
    };

    ctxt = Maps.transformValues(repres, pack_dense);

    for (Equation eq : equations) {
        if (eq instanceof Equality) {
            final Unknown l = ((Equality) eq).lhs;
            final Unknown r = ((Equality) eq).rhs;
            final Unknown min = Ordering.natural().min(l, r);

            if (min.der != 0)
                be.add(eq.bind(ctxt));
        } else {
            be.add(eq.bind(ctxt));
        }
    }

    reduced = be.build();

    this.unknowns = ImmutableSortedSet.copyOf(ctxt.values());

}

From source file:io.github.swagger2markup.extensions.DynamicContentExtension.java

/**
 * Builds extension sections//from www . j a v a2  s. c o m
 *
 * @param extensionMarkupLanguage the MarkupLanguage of the snippets content
 * @param contentPath the path where the content files reside
 * @param prefix      extension file prefix
 * @param levelOffset import markup level offset
 */
public void extensionsSection(MarkupLanguage extensionMarkupLanguage, Path contentPath, final String prefix,
        int levelOffset) {
    final Collection<String> filenameExtensions = globalContext.getConfig().getMarkupLanguage()
            .getFileNameExtensions().stream().map(fileExtension -> StringUtils.stripStart(fileExtension, "."))
            .collect(Collectors.toList());

    DirectoryStream.Filter<Path> filter = entry -> {
        String fileName = entry.getFileName().toString();
        return fileName.startsWith(prefix) && FilenameUtils.isExtension(fileName, filenameExtensions);
    };

    try (DirectoryStream<Path> extensionFiles = Files.newDirectoryStream(contentPath, filter)) {

        if (extensionFiles != null) {
            List<Path> extensions = Lists.newArrayList(extensionFiles);
            Collections.sort(extensions, Ordering.natural());

            for (Path extension : extensions) {
                importContent(extension, (reader) -> contentContext.getMarkupDocBuilder().importMarkup(reader,
                        extensionMarkupLanguage, levelOffset));
            }
        }
    } catch (IOException e) {
        if (logger.isDebugEnabled())
            logger.debug("Failed to read extension files from directory {}", contentPath);
    }
}

From source file:org.pentaho.community.di.impl.provider.HorizontalLayout.java

@Override
public void applyLayout(Graph graph, int canvasWidth, int canvasHeight) {
    GremlinPipeline<Graph, Vertex> pipe = new GremlinPipeline<>(graph);
    List<Vertex> vertices = pipe.V().as("loop")
            // Set degree for each vertex
            .transform(new PipeFunction<Vertex, Iterable<Vertex>>() {
                @Override//from  w w  w  .  j ava 2 s  .  c  o m
                public Iterable<Vertex> compute(Vertex vertex) {
                    FluentIterable<Integer> degrees = FluentIterable.from(vertex.getVertices(Direction.IN))
                            .transform(GraphUtils.<Integer>getProperty(PROPERTY_COLUMN));

                    ImmutableList.Builder<Vertex> output = ImmutableList.builder();
                    // If no inputs, rank as 0
                    if (degrees.isEmpty()) {
                        vertex.setProperty(PROPERTY_COLUMN, 0);
                    } else {
                        // Find max degree of all inputs
                        Integer value = Ordering.natural().nullsLast().max(degrees);
                        if (value != null) {
                            vertex.setProperty(PROPERTY_COLUMN, value + 1);
                        } else {
                            output.addAll(vertex.getVertices(Direction.IN));
                        }
                    }
                    output.add(vertex);
                    return output.build();
                }
            }).scatter().cast(Vertex.class)
            .loop("loop", new PipeFunction<LoopPipe.LoopBundle<Vertex>, Boolean>() {
                @Override
                public Boolean compute(LoopPipe.LoopBundle<Vertex> argument) {
                    return !argument.getObject().getPropertyKeys().contains(PROPERTY_COLUMN);
                }
            }).dedup().groupBy(new PipeFunction<Vertex, Integer>() {
                @Override
                public Integer compute(Vertex vertex) {
                    return vertex.getProperty(PROPERTY_COLUMN);
                }
            }, new PipeFunction<Vertex, Vertex>() {
                @Override
                public Vertex compute(Vertex vertex) {
                    return vertex;
                }
            }, new PipeFunction<List<Vertex>, List<Vertex>>() {
                @Override
                public List<Vertex> compute(List<Vertex> group) {
                    int row = 0;
                    for (Vertex vertex : group) {
                        vertex.setProperty(PROPERTY_ROW, row++);
                    }
                    return group;
                }
            }).toList();

    int columnWidth = canvasWidth / 5;
    int rowWidth = canvasHeight / 8;
    for (Vertex vertex : vertices) {
        int column = vertex.getProperty(PROPERTY_COLUMN);
        int row = vertex.getProperty(PROPERTY_ROW);
        vertex.setProperty(GraphUtils.PROPERTY_X, columnWidth / 2 + column * columnWidth);
        vertex.setProperty(GraphUtils.PROPERTY_Y, rowWidth / 2 + row * rowWidth);
    }

    System.out.println(vertices);
}

From source file:org.glowroot.agent.weaving.preinit.GlobalCollector.java

public List<String> usedInternalNames() {
    List<String> internalNames = Lists.newArrayList();
    for (String internalName : Ordering.natural().sortedCopy(classCollectors.keySet())) {
        if (!InternalNames.inBootstrapClassLoader(internalName) && !internalName.startsWith("org/slf4j/")
                && !internalName.startsWith("org/glowroot/agent/shaded/slf4j/")
                && InternalNames.exists(internalName)) {
            internalNames.add(internalName.replace('/', '.'));
        }//from   ww  w.j  a va2s  .  co m
    }
    return internalNames;
}

From source file:org.apache.crunch.Pair.java

private int cmp(Object lhs, Object rhs) {
    if (lhs == rhs) {
        return 0;
    } else if (lhs != null && Comparable.class.isAssignableFrom(lhs.getClass())) {
        return Ordering.natural().nullsLast().compare((Comparable) lhs, (Comparable) rhs);//(Comparable) lhs).compareTo(rhs);
    }//from ww  w  . java 2  s  . com
    if (lhs == null) {
        return 1; // nulls last
    }
    if (rhs == null) {
        return -1; // nulls last
    }
    if (lhs.equals(rhs)) {
        return 0;
    }

    // Now we compare based on hash code. We already know that the two sides are not equal, so
    // if the hash codes are equal, we just use arbitrary (but consistent) ordering
    return ComparisonChain.start().compare(lhs.hashCode(), rhs.hashCode())
            .compare(lhs, rhs, Ordering.arbitrary()).result();
}

From source file:com.facebook.buck.features.project.intellij.model.AbstractIjModuleAndroidFacet.java

/** @return The minimum Android SDK version supported. */
@Value.Lazy/* w  w  w.ja v a 2s .co  m*/
public Optional<String> getMinSdkVersion() {
    Ordering<String> byIntegerValue = Ordering.natural().onResultOf(Integer::valueOf);
    return getMinSdkVersions().stream().min(byIntegerValue);
}

From source file:com.sun.tools.hat.internal.server.FinalizerSummaryQuery.java

private void printFinalizerSummary(Collection<? extends JavaHeapObject> objs) {
    int count = 0;
    Multiset<JavaClass> bag = HashMultiset.create();

    for (JavaHeapObject obj : objs) {
        count++;//www . j a  va  2 s .c  o  m
        bag.add(obj.getClazz());
    }

    out.println("<p align='center'>");
    out.println("<b>");
    out.println("Total ");
    if (count != 0) {
        out.print("<a href='/finalizerObjects/'>instances</a>");
    } else {
        out.print("instances");
    }
    out.println(" pending finalization: ");
    out.print(count);
    out.println("</b></p><hr>");

    if (count == 0) {
        return;
    }

    // calculate and print histogram
    out.println("<table border=1 align=center>");
    out.println("<tr><th>Count</th><th>Class</th></tr>");
    bag.entrySet().stream().sorted(Ordering.natural().reverse().onResultOf(entry -> entry.getCount()))
            .forEach(entry -> {
                out.println("<tr><td>");
                out.println(entry.getCount());
                out.println("</td><td>");
                printClass(entry.getElement());
                out.println("</td><tr>");
            });
    out.println("</table>");
}

From source file:org.nmdp.service.epitope.service.EpitopeServiceImpl.java

public void buildMaps() {
    ImmutableListMultimap.Builder<Integer, Allele> builder = ImmutableListMultimap.builder();
    builder.orderKeysBy(Ordering.natural());
    builder.orderValuesBy(new Comparator<Allele>() {
        @Override/* ww w  . j a v  a  2  s .  c om*/
        public int compare(Allele o1, Allele o2) {
            return o1.getGlstring().compareTo(o2.getGlstring());
        }
    });
    for (int i = 0; i <= 3; i++) {
        Integer group = i;
        List<Allele> alleles = groupResolver.apply(group);
        if (null == alleles) {
            throw new IllegalStateException("failed to resolve alleles in group: " + group);
        }
        for (Allele allele : alleles)
            builder.put(group, allele);
    }
    groupAlleleMap = builder.build();
    alleleGroupMap = groupAlleleMap.inverse();
}