Java 类com.google.common.collect.Ordering 实例源码

public List<Revision> getRevisions(String id, Params params) {

        AuditReader reader = getAuditReader();

        List<Number> revisionNumbers = reader.getRevisions(type, id);
        Map<Number, Revision> revisionMap = reader.findRevisions(Revision.class, asSet(revisionNumbers));
        Collection<Revision> revisions = revisionMap.values();

        Comparator<Revision> timestampComparator = Comparator.comparingLong(Revision::getTimestamp);
        Comparator<Revision> authorComparator = Comparator.comparing(Revision::getAuthor);

        Comparator<Revision> comparator;
        if (AUTHOR.equals(params.getSort())) {
            comparator = authorComparator;
        } else {
            comparator = timestampComparator;
        }

        if (params.getOrder() == Order.DESC) {
            comparator = comparator.reversed();
        }

        return Ordering.from(comparator)
                       .sortedCopy(revisions);
    }

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

/**
 * 测试 TreeMultimap,自定义数据结构的排序
 */
@Test
public void testSelfDataOrdered() {
    // 创建TreeMultimap,使用Ordering.natural()指定自然排序,Ordering.from指定排序规则
    // Order4TreeMultimap::compareTo 是lambda的简写形式
    TreeMultimap<String, Order4TreeMultimap> treeMultimap = TreeMultimap
            .create(Ordering.natural(),
                    Ordering.from(Order4TreeMultimap::compareTo));

    // 列表2
    treeMultimap.put("order_list1", new Order4TreeMultimap(1, "haha1"));
    treeMultimap.put("order_list1", new Order4TreeMultimap(5, "haha2"));
    treeMultimap.put("order_list1", new Order4TreeMultimap(9, "haha3"));
    treeMultimap.put("order_list1", new Order4TreeMultimap(10, "haha3"));
    treeMultimap.put("order_list1", new Order4TreeMultimap(22, "haha4"));
    treeMultimap.put("order_list1", new Order4TreeMultimap(444, "haha5"));

    // 列表2
    treeMultimap.put("order_list2", new Order4TreeMultimap(1, "haha3"));
    treeMultimap.put("order_list2", new Order4TreeMultimap(3, "haha4"));
    treeMultimap.put("order_list3", new Order4TreeMultimap(2, "haha5"));

    // 输出
    treeMultimap.forEach((key, order) -> System.out.println("key=" + key + ",order=" + order));
}

/**
 * Sets the points a {@link PlayerFaction} has gained for this {@link ConquestTracker}.
 *
 * @param faction the faction to set for
 * @param amount  the amount to set
 * @return the new points of the {@link PlayerFaction}
 */
public int setPoints(PlayerFaction faction, int amount) {
    if (amount <= 0) return amount;

    synchronized (factionPointsMap) {
        factionPointsMap.put(faction, amount);
        List<Map.Entry<PlayerFaction, Integer>> entries = Ordering.from(POINTS_COMPARATOR).sortedCopy(factionPointsMap.entrySet());

        factionPointsMap.clear();
        for (Map.Entry<PlayerFaction, Integer> entry : entries) {
            factionPointsMap.put(entry.getKey(), entry.getValue());
        }
    }

    return amount;
}

@Override
@SuppressWarnings({ "rawtypes", "unchecked", "static-access" })
protected Comparator getItemsComparator() {
    return Ordering.natural().nullsLast().from(new Comparator() {

        @Override
        public int compare(final Object o1, final Object o2) {
            if (o1 instanceof IEObjectDescription && o2 instanceof IEObjectDescription) {
                final IEObjectDescription d1 = (IEObjectDescription) o1;
                final IEObjectDescription d2 = (IEObjectDescription) o2;
                final QualifiedName fqn1 = d1.getQualifiedName();
                final QualifiedName fqn2 = d2.getQualifiedName();
                if (null != fqn1 && null != fqn2) {
                    return nullToEmpty(fqn1.getLastSegment()).compareToIgnoreCase(
                            nullToEmpty(fqn2.getLastSegment()));
                }
            }
            return Objects.hashCode(o1) - Objects.hashCode(o2);
        }
    });
}

private OrderingByPosition (int position, boolean reverse, @Nullable Boolean nullFirst) {
    this.position = position;

    // note, that we are reverse for the queue so this conditional is by intent
    Ordering<Comparable> ordering;
    nullFirst = nullFirst != null ? !nullFirst : null; // swap because queue is reverse
    if (reverse) {
        ordering = Ordering.natural();
        if (nullFirst == null || !nullFirst) {
            ordering = ordering.nullsLast();
        } else {
            ordering = ordering.nullsFirst();
        }
    } else {
        ordering = Ordering.natural().reverse();
        if (nullFirst == null || nullFirst) {
            ordering = ordering.nullsFirst();
        } else {
            ordering = ordering.nullsLast();
        }
    }
    this.ordering = ordering;
}

/**
 * Asserts that the metric has no (non-default) values other than those about which an assertion
 * has already been made.
 */
public And<S> hasNoOtherValues() {
  for (MetricPoint<T> metricPoint : actual().getTimestampedValues()) {
    if (!expectedNondefaultLabelTuples.contains(metricPoint.labelValues())) {
      if (!hasDefaultValue(metricPoint)) {
        failWithBadResults(
            "has",
            "no other nondefault values",
            "has labeled values",
            Lists.transform(
                Ordering.<MetricPoint<T>>natural().sortedCopy(actual().getTimestampedValues()),
                metricPointConverter));
      }
      return andChainer();
    }
  }
  return andChainer();
}

private List<Integer> topKProbabilities(final float[] labelProbabilities, int k) {

        List<Integer> list = new ArrayList<>(labelProbabilities.length);
        for (int i = 0; i < labelProbabilities.length; i++) {
            list.add(i);
        }

        List<Integer> topK = new Ordering<Integer>() {
            @Override
            public int compare(Integer left, Integer right) {
                return Floats.compare(labelProbabilities[left], labelProbabilities[right]);
            }
        }.greatestOf(list, k);

        return topK;
    }

private List<SuggestItem> pickSuggestions(String searchWord, int editDistanceMax, List<SuggestItem> suggestions) {
    int k = suggestions.size();
    if ((accuracyLevel == AccuracyLevel.topHit) && (suggestions.size() > 1))
        k = 1;
    else if (suggestions.size() > topK) {
        k = topK;
    }

    List<SuggestItem> returnSuggestions;
    if (k >= suggestions.size()) {
        returnSuggestions = suggestions;
    } else {
        returnSuggestions = Ordering.from(distanceCountComparator).leastOf(suggestions, k);
    }

    return customizing.adjustFinalResult(searchWord, returnSuggestions);
}

public final CorpusQueryAssessments withNeutralizedJustifications() {
  return CorpusQueryAssessments.builder()
      .queryReponses(Iterables.transform(queryReponses(), neutralizeRealisFunction()))
      .queryResponsesToSystemIDs(
          copyWithTransformedKeys(queryResponsesToSystemIDs(), neutralizeRealisFunction()))
      .assessments(
          reduceToMap(
              transformKeys(assessments(), neutralizeRealisFunction()),
              // if multiple assessments on the same doc are collapsed together,
              // the ones higher in rank "trump" others
              maxFunction(Ordering.<QueryAssessment2016>natural())))
      // we arbitrarily take the first metadata, which is a bit of a hack
      .metadata(reduceToMap(transformKeys(metadata(), neutralizeRealisFunction()),
          _CorpusQueryAssessments.<String>getFirstFunction()))
      .build();
}

/**
 * @param inputs             contains output {@link io.crate.operation.Input}s and orderBy {@link io.crate.operation.Input}s
 * @param collectExpressions gathered from outputs and orderBy inputs
 * @param numOutputs         <code>inputs</code> contains this much output {@link io.crate.operation.Input}s starting form index 0
 * @param ordering           ordering that is used to compare the rows
 * @param limit              the number of rows to gather, pass to upStream
 * @param offset             the initial offset, this number of rows are skipped
 */
public SortingTopNProjector(Collection<? extends Input<?>> inputs,
                            Iterable<? extends CollectExpression<Row, ?>> collectExpressions,
                            int numOutputs,
                            Ordering<Object[]> ordering,
                            int limit,
                            int offset) {
    Preconditions.checkArgument(limit >= TopN.NO_LIMIT, "invalid limit");
    Preconditions.checkArgument(offset >= 0, "invalid offset");

    this.inputs = inputs;
    this.numOutputs = numOutputs;
    this.collectExpressions = collectExpressions;
    this.offset = offset;

    if (limit == TopN.NO_LIMIT) {
        limit = Constants.DEFAULT_SELECT_LIMIT;
    }
    int maxSize = this.offset + limit;
    pq = new RowPriorityQueue<>(maxSize, ordering);
}

@Test
public void customComparable() {
  MutableGraph<ComparableSubClass> graph =
      GraphBuilder.undirected().nodeOrder(ElementOrder.<ComparableSubClass>natural()).build();

  ComparableSubClass node2 = new ComparableSubClass(2);
  ComparableSubClass node4 = new ComparableSubClass(4);
  ComparableSubClass node6 = new ComparableSubClass(6);
  ComparableSubClass node8 = new ComparableSubClass(8);

  graph.addNode(node4);
  graph.addNode(node2);
  graph.addNode(node6);
  graph.addNode(node8);

  assertThat(graph.nodeOrder().comparator()).isEqualTo(Ordering.natural());
  assertThat(graph.nodes()).containsExactly(node2, node4, node6, node8).inOrder();
}

@Override
public int getValueCapacity() {
  if (size() == 0) {
    return 0;
  }

  final Ordering<ValueVector> natural = new Ordering<ValueVector>() {
    @Override
    public int compare(@Nullable ValueVector left, @Nullable ValueVector right) {
      return Ints.compare(
          Preconditions.checkNotNull(left).getValueCapacity(),
          Preconditions.checkNotNull(right).getValueCapacity()
      );
    }
  };

  return natural.min(getChildren()).getValueCapacity();
}

/**
 * @return A mapping from each breakdown type to inner maps. These inner maps map from the
 * categories for that breakdown type to confusion matrices for only that category.
 */
public static <SignatureType, ProvenanceType>
ImmutableMap<String, BrokenDownProvenancedConfusionMatrix<SignatureType, ProvenanceType>>
computeBreakdowns(
    ProvenancedConfusionMatrix<ProvenanceType> corpusConfusionMatrix,
    Map<String, Function<? super ProvenanceType, SignatureType>> breakdowns,
    Ordering<SignatureType> resultKeyOrdering) {
  final ImmutableMap.Builder<String, BrokenDownProvenancedConfusionMatrix<SignatureType, ProvenanceType>>
      printModes =
      ImmutableMap.builder();

  for (final Map.Entry<String, Function<? super ProvenanceType, SignatureType>> breakdownEntry : breakdowns
      .entrySet()) {
    printModes.put(breakdownEntry.getKey(),
        corpusConfusionMatrix.breakdown(breakdownEntry.getValue(),
            resultKeyOrdering));
  }
  return printModes.build();
}

public static ImmutableMap<String, BrokenDownSummaryConfusionMatrix<Symbol>> combineBreakdowns(
    Iterator<Map<String, BrokenDownSummaryConfusionMatrix<Symbol>>> breakdowns) {

  final Map<String, BrokenDownSummaryConfusionMatrix.Builder<Symbol>> ret = Maps.newHashMap();
  while (breakdowns.hasNext()) {
    final Map<String, BrokenDownSummaryConfusionMatrix<Symbol>> breakdown = breakdowns.next();
    for (final Map.Entry<String, BrokenDownSummaryConfusionMatrix<Symbol>> breakdownEntry : breakdown
        .entrySet()) {
      if (!ret.containsKey(breakdownEntry.getKey())) {
        ret.put(breakdownEntry.getKey(), BrokenDownSummaryConfusionMatrix.<Symbol>builder(
            Ordering.from(new SymbolUtils.ByString())));
      }
      ret.get(breakdownEntry.getKey()).combine(breakdownEntry.getValue());
    }
  }

  final ImmutableMap.Builder<String, BrokenDownSummaryConfusionMatrix<Symbol>> trueRet =
      ImmutableMap.builder();
  // return map in alphabetical order
  for (final String key : Ordering.natural().sortedCopy(ret.keySet())) {
    trueRet.put(key, ret.get(key).build());
  }
  return trueRet.build();
}

public DatatypeDate(final Comparator<Date> comparator, final String dateFormat) {
  this.specificType = type.DATE;
  this.setDateFormat(dateFormat);

  if (comparator == null) {
    this.indexedComparator = new Comparator<RowIndexedDateValue>() {

      @Override
      public int compare(final RowIndexedDateValue o1, final RowIndexedDateValue o2) {
        return ComparisonChain.start()
            .compare(o1.value, o2.value, Ordering.natural().nullsFirst()).result();
      }

    };
  } else {
    this.indexedComparator = new Comparator<RowIndexedDateValue>() {

      @Override
      public int compare(final RowIndexedDateValue o1, final RowIndexedDateValue o2) {
        return ComparisonChain.start()
            .compare(o1.value, o2.value, Ordering.from(comparator).nullsFirst()).result();
      }

    };
  }
}

public DatatypeLong(final Comparator<Long> comparator) {
  this.specificType = type.LONG;

  if (comparator == null) {
    this.indexedComparator = new Comparator<RowIndexedLongValue>() {

      @Override
      public int compare(final RowIndexedLongValue o1, final RowIndexedLongValue o2) {
        return ComparisonChain.start()
            .compare(o1.value, o2.value, Ordering.natural().nullsFirst()).result();
      }

    };
  } else {
    this.indexedComparator = new Comparator<RowIndexedLongValue>() {

      @Override
      public int compare(final RowIndexedLongValue o1, final RowIndexedLongValue o2) {
        return ComparisonChain.start()
            .compare(o1.value, o2.value, Ordering.from(comparator).nullsFirst()).result();
      }

    };
  }

}

/**
 * Obtains a min-hash set for the given input file
 * @param indx the unique index assigned for this file
 * @param x_file the file to get the LZJDf min-hash of
 * @param min_hash_size the max size for the min-hash
 * @return an int array of the min-hash values in sorted order
 * @throws IOException 
 */
protected static int[] getMinHash(int indx, File x_file, int min_hash_size) throws IOException
{
    int[] x_minset = min_hashes.get(indx);
    if(x_minset == null)
    {
        try(FileInputStream fis = new FileInputStream(x_file))
        {
            IntList hashes = LOCAL_INT_LIST.get();
            hashes.clear();
            getAllHashes(hashes, fis);

            List<Integer> sub_hashes = Ordering.natural().leastOf(hashes, Math.min(min_hash_size, hashes.size()));

            x_minset = new int[sub_hashes.size()];
            for(int i = 0; i < x_minset.length; i++)
                x_minset[i] = sub_hashes.get(i);
            Arrays.sort(x_minset);

            min_hashes.putIfAbsent(indx, x_minset);
        }
    }

    return x_minset;
}

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));
    }
  }
}

/**
 * Sets the points a {@link PlayerFaction} has gained for this {@link ConquestTracker}.
 *
 * @param faction the faction to set for
 * @param amount  the amount to set
 * @return the new points of the {@link PlayerFaction}
 */
public int setPoints(PlayerFaction faction, int amount) {
    if (amount <= 0) return amount;

    synchronized (factionPointsMap) {
        factionPointsMap.put(faction, amount);
        List<Map.Entry<PlayerFaction, Integer>> entries = Ordering.from(POINTS_COMPARATOR).sortedCopy(factionPointsMap.entrySet());

        factionPointsMap.clear();
        for (Map.Entry<PlayerFaction, Integer> entry : entries) {
            factionPointsMap.put(entry.getKey(), entry.getValue());
        }
    }

    return amount;
}

@Test
public void nodeOrderUnorderedandEdgesSorted() {
  MutableNetwork<Integer, String> network =
      NetworkBuilder.directed()
          .nodeOrder(unordered())
          .edgeOrder(ElementOrder.sorted(Ordering.<String>natural().reverse()))
          .build();

  addEdges(network);

  assertThat(network.edgeOrder())
      .isEqualTo(ElementOrder.sorted(Ordering.<String>natural().reverse()));
  assertThat(network.edges()).containsExactly("p", "i", "e").inOrder();
  assertThat(network.nodeOrder()).isEqualTo(unordered());
  assertThat(network.nodes()).containsExactly(4, 1, 3);
}

/**
 * Records are sorted by lexical position of their definition Element.
 * Records without an Element are ordered before those with an Element,
 * and two different records NEVER compare equal.
 */
@Override
public int compareTo(Record<?> that) {
    assertDefined();
    if(this == that) return 0;
    if(this.path == null) {
        if(that.path == null) {
            return Ordering.arbitrary().compare(this, that);
        } else {
            return -1;
        }
    } else {
        if(that.path == null) {
            return 1;
        } else {
            return ListUtils.lexicalCompare(this.path, that.path);
        }
    }
}

/**
 * Displays partition client info as text.
 *
 * @param partitionClientInfo partition client information
 */
private void displayPartitionClients(List<PartitionClientInfo> partitionClientInfo) {
    if (partitionClientInfo.isEmpty()) {
        return;
    }
    ClusterService clusterService = get(ClusterService.class);
    print("-------------------------------------------------------------------");
    print(CLIENT_FMT, "Name", "SessionId", "Status", "Servers");
    print("-------------------------------------------------------------------");

    for (PartitionClientInfo info : partitionClientInfo) {
        boolean first = true;
        for (NodeId serverId : Ordering.natural().sortedCopy(info.servers())) {
            ControllerNode server = clusterService.getNode(serverId);
            String serverString = String.format("%s:%d", server.id(), server.tcpPort());
            if (first) {
                print(CLIENT_FMT, info.partitionId(), info.sessionId(),
                        info.status(), serverString);
                first = false;
            } else {
                print(CLIENT_FMT, "", "", "", serverString);
            }
        }
        if (!first) {
            print("-------------------------------------------------------------------");
        }
    }
}

ImmutableMap<Service, Long> startupTimes() {
  List<Entry<Service, Long>> loadTimes;
  monitor.enter();
  try {
    loadTimes = Lists.newArrayListWithCapacity(startupTimers.size());
    // N.B. There will only be an entry in the map if the service has started
    for (Entry<Service, Stopwatch> entry : startupTimers.entrySet()) {
      Service service = entry.getKey();
      Stopwatch stopWatch = entry.getValue();
      if (!stopWatch.isRunning() && !(service instanceof NoOpService)) {
        loadTimes.add(Maps.immutableEntry(service, stopWatch.elapsed(MILLISECONDS)));
      }
    }
  } finally {
    monitor.leave();
  }
  Collections.sort(
      loadTimes,
      Ordering.natural()
          .onResultOf(
              new Function<Entry<Service, Long>, Long>() {
                @Override
                public Long apply(Map.Entry<Service, Long> input) {
                  return input.getValue();
                }
              }));
  return ImmutableMap.copyOf(loadTimes);
}

public void writeAnnotation(TypeKey annotationType,
                            Collection<? extends AnnotationElement> elements) throws IOException {
    writer.writeEncodedValueHeader(ValueType.ANNOTATION, 0);
    writer.writeUleb128(typeSection.getItemIndex(annotationType));
    writer.writeUleb128(elements.size());

    Collection<? extends AnnotationElement> sortedElements = Ordering.from(BaseAnnotationElement.BY_NAME)
            .immutableSortedCopy(elements);

    for (AnnotationElement element: sortedElements) {
        writer.writeUleb128(stringSection.getItemIndex(annotationSection.getElementName(element)));
        writeEncodedValue(annotationSection.getElementValue(element));
    }
}

private static void validateType(StructBindingValidationProblemCollector problems, Class<?> typeClass) {
    Constructor<?> customConstructor = findCustomConstructor(typeClass);
    if (customConstructor != null) {
        problems.add(customConstructor, "Custom constructors are not supported.");
    }

    ensureNoInstanceScopedFields(problems, typeClass);

    // sort for determinism
    Method[] methods = typeClass.getDeclaredMethods();
    Arrays.sort(methods, Ordering.usingToString());

    ensureNoProtectedOrPrivateMethods(problems, methods);
    ensureNoDefaultMethods(problems, typeClass, methods);
}

private static <K, V> ImmutableList<K> sortKeysByValue(
    final Map<K, V> map, final Comparator<? super V> valueComparator) {
  Ordering<K> keyOrdering =
      new Ordering<K>() {
        @Override
        public int compare(K left, K right) {
          return valueComparator.compare(map.get(left), map.get(right));
        }
      };
  return keyOrdering.immutableSortedCopy(map.keySet());
}

public static <T> Ordering<ModelType<? extends T>> displayOrder() {
    return new Ordering<ModelType<? extends T>>() {
        @Override
        public int compare(ModelType<? extends T> left, ModelType<? extends T> right) {
            return left.getDisplayName().compareTo(right.getDisplayName());
        }
    };
}

@Override
@SuppressWarnings("StringEquality")
public DefaultBuildInvocations buildAll(String modelName, Project project) {
    if (!canBuild(modelName)) {
        throw new GradleException("Unknown model name " + modelName);
    }

    DefaultProjectIdentifier projectIdentifier = getProjectIdentifier(project);
    // 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).
                setProjectIdentifier(projectIdentifier).
                setDisplayName(selectorName + " in " + project + " and subprojects.").
                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)
        .setProjectIdentifier(projectIdentifier);
}

public int compareTo(VersionNumber other) {
    if (major != other.major) {
        return major - other.major;
    }
    if (minor != other.minor) {
        return minor - other.minor;
    }
    if (micro != other.micro) {
        return micro - other.micro;
    }
    if (patch != other.patch) {
        return patch - other.patch;
    }
    return Ordering.natural().nullsLast().compare(toLowerCase(qualifier), toLowerCase(other.qualifier));
}

/** Create a cycle in 'graph' comprised of classes from 'classes'. */
private static void putOnCycle(Collection<String> classes, MutableGraph<String> graph) {
  if (classes.size() == 1) {
    return;
  }

  ImmutableList<String> sortedClasses = Ordering.natural().immutableSortedCopy(classes);

  for (int i = 1; i < sortedClasses.size(); i++) {
    graph.putEdge(sortedClasses.get(i - 1), sortedClasses.get(i));
  }
  graph.putEdge(getLast(sortedClasses), sortedClasses.get(0));
}

@Override public void foo(
    String s, Runnable r, Number n, Iterable<?> it, boolean b, Equivalence<String> eq,
    Exception e, InputStream in, Comparable<?> c, Ordering<Integer> ord,
    Charset charset, TimeUnit unit, Class<?> cls, Joiner joiner,
    Pattern pattern, UnsignedInteger ui, UnsignedLong ul, StringBuilder sb,
    Predicate<?> pred, Function<?, ?> func, Object obj) {
  delegate.foo(s,
      r, n, it, b, eq, e, in, c, ord, charset, unit, cls, joiner, pattern,
      ui, ul, sb, pred, func, obj);
}

ImmutableList<K> collectTypes(Iterable<? extends K> types) {
  // type -> order number. 1 for Object, 2 for anything directly below, so on so forth.
  Map<K, Integer> map = Maps.newHashMap();
  for (K type : types) {
    collectTypes(type, map);
  }
  return sortKeysByValue(map, Ordering.natural().reverse());
}

public Iterable<Event> pastEvents(float lastPollTime, float time)
{
    float clipLastPollTime = input.apply(lastPollTime);
    float clipTime = input.apply(time);
    return Iterables.mergeSorted(ImmutableSet.of(
        from.pastEvents(clipLastPollTime, clipTime),
        to.pastEvents(clipLastPollTime, clipTime)
    ), Ordering.<Event>natural());
}

@Override
public int compareTo(FunctionIdent o) {
    return ComparisonChain.start()
            .compare(name, o.name)
            .compare(argumentTypes, o.argumentTypes, Ordering.<DataType>natural().lexicographical())
            .result();
}

/**
 * Test a simple configuration.
 */
@Test
public void testSimple() {
  ViewChanges c = new ViewChanges(
    ImmutableSet.of(
      view("A", "B", "C"),
      view("B", "C", "D"),
      view("C"),
      view("D")
    ),
    ImmutableSet.of(
      view("B")
    ),
    ImmutableSet.of(
      view("A"),
      view("B")
    ));

  assertEquals("Views to drop mismatch", ImmutableSet.of("B", "A"), nameSet(c.getViewsToDrop()));
  assertEquals("Views to deploy mismatch", ImmutableSet.of("A", "B"), nameSet(c.getViewsToDeploy()));

  Ordering<String> dropOrder = Ordering.explicit(nameList(c.getViewsToDrop()));
  assertTrue("Must drop A before B", dropOrder.compare("A", "B") < 0);

  Ordering<String> deployOrder = Ordering.explicit(nameList(c.getViewsToDeploy()));
  assertTrue("Must deploy B before A", deployOrder.compare("B", "A") < 0);
}

@Override
public Iterable<Entry<String, Integer>> order(List<Entry<String, Integer>> insertionOrder) {
  return new Ordering<Entry<String, Integer>>() {
    @Override
    public int compare(Entry<String, Integer> left, Entry<String, Integer> right) {
      return left.getKey().compareTo(right.getKey());
    }
  }.sortedCopy(insertionOrder);
}

private HashCode computeSHA1Hash() {
  final Hasher hasher = SHA1_HASHER.newHasher()
      .putString(docID().toString(), Charsets.UTF_8)
      .putString(type().toString(), Charsets.UTF_8)
      .putString(role().toString(), Charsets.UTF_8)
      .putString(canonicalArgument().string(), Charsets.UTF_8)
      .putInt(canonicalArgument().charOffsetSpan().startInclusive())
      .putInt(canonicalArgument().charOffsetSpan().endInclusive())
      .putInt(baseFiller().startInclusive())
      .putInt(baseFiller().endInclusive());

  // we put PJ_CODE and AAJ_CODE into the hash because without them,
  // observe that shifting a second PJ element to being the first AAJ
  // element results in the same hash
  hasher.putInt(PJ_CODE);
  for (final CharOffsetSpan pj : Ordering.natural().sortedCopy(predicateJustifications())) {
    hasher.putInt(pj.startInclusive()).putInt(pj.endInclusive());
  }

  hasher.putInt(AAJ_CODE);
  for (final CharOffsetSpan aaj : Ordering.natural().sortedCopy(
      additionalArgumentJustifications())) {
    hasher.putInt(aaj.startInclusive()).putInt(aaj.endInclusive());
  }

  hasher.putInt(realis().ordinal());

  return hasher.hash();
}

@Override
public int compare(final Response left, final Response right) {
  return ComparisonChain.start()
      .compare(left.docID().toString(), right.docID().toString())
      .compare(
          Ordering.natural().sortedCopy(left.predicateJustifications()),
          Ordering.natural().sortedCopy(right.predicateJustifications()),
          Ordering.<CharOffsetSpan>natural().lexicographical())
      .compare(left.baseFiller(), right.baseFiller())
      .compare(left.canonicalArgument().charOffsetSpan(),
          right.canonicalArgument().charOffsetSpan())
      .compare(left.realis(), right.realis())
      .result();
}

public List<Message> getMessages() {
  if (root.errors == null) {
    return ImmutableList.of();
  }

  return new Ordering<Message>() {
    @Override
    public int compare(Message a, Message b) {
      return a.getSource().compareTo(b.getSource());
    }
  }.sortedCopy(root.errors);
}