Class ArbitraryOrdering

output/java_guava/1.4.16/Ordering.java:313–365

  }

  @VisibleForTesting
  static class ArbitraryOrdering extends Ordering<Object> {
    @SuppressWarnings("deprecation") // TODO(kevinb): ?
    private final Map<Object, Integer> uids = Platform.tryWeakKeys(new MapMaker()).makeComputingMap(new Function<Object, Integer>() {
                                                                                                      final AtomicInteger counter = new AtomicInteger(0);

                                                                                                      @Override
                                                                                                      public Integer apply(Object from) {
                                                                                                        return counter.getAndIncrement();
                                                                                                      }
                                                                                                    });

    @Override
    public int compare(Object left, Object right) {
      if (left == right) {
        return 0;
      } else if (left == null) {
        return -1;
      } else if (right == null) {
        return 1;
      }
      int leftCode = identityHashCode(left);
      int rightCode = identityHashCode(right);
      if (leftCode != rightCode) {
        return leftCode < rightCode ? -1 : 1;
      }

      // identityHashCode collision (rare, but not as rare as you'd think)
      int result = uids.get(left).compareTo(uids.get(right));
      if (result == 0) {
        throw new AssertionError(); // extremely, extremely unlikely.
      }
      return result;
    }

    @Override
    public String toString() {
      return "Ordering.arbitrary()";
    }

    /*
     * We need to be able to mock identityHashCode() calls for tests, because it
     * can take 1-10 seconds to find colliding objects. Mocking frameworks that
     * can do magic to mock static method calls still can't do so for a system
     * class, so we need the indirection. In production, Hotspot should still
     * recognize that the call is 1-morphic and should still be willing to
     * inline it if necessary.
     */

    int identityHashCode(Object object) {
      return System.identityHashCode(object);
    }
  }

  // Constructor