Class ArbitraryOrdering

corpus/java/training/guava/collect/Ordering.java:306–361

  }

  @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