}

    /**
     * Configures this {@code Builder} to order entries by value according to the specified
     * comparator.
     *
     * <p>The sort order is stable, that is, if two entries have values that compare as equivalent,
     * the entry that was inserted first will be first in the built map's iteration order.
     *
     * @throws IllegalStateException if this method was already called
     * @since 19.0
     */

	// Prefer lower types
	if x.Type != o.Type {
		return x.Type < o.Type
	}
	// Consistent sort on signature
	if v := bytes.Compare(x.Signature[:], o.Signature[:]); v != 0 {
		return v > 0
	}
	// On ID mismatch
	if v := bytes.Compare(x.VersionID[:], o.VersionID[:]); v != 0 {
		return v > 0
	}
	// Flags
	if x.Flags != o.Flags {
		return x.Flags > o.Flags
	}
	return false
}

  @Generates
  <T extends @Nullable Object> Ordering<T> generateOrdering() {
    return new Ordering<T>() {
      @Override
      @SuppressWarnings("UnusedVariable") // intentionally weird Comparator
      public int compare(T left, T right) {
        return 0;
      }

      final String string = paramString(Ordering.class, generateInt());

      @Override
      public String toString() {
        return string;
      }

# Alternatives, inspiration et comparaisons

Ce qui a inspiré **FastAPI**, comment il se compare à d'autres solutions et ce qu'il en a appris.

## Intro

**FastAPI** n'existerait pas sans les précédentes contributions d'autres projets.

De nombreux outils ont été créés auparavant et ont contribué à inspirer sa création.

J'ai évité la création d'un nouveau framework pendant plusieurs années. J'ai d'abord essayé de combler toutes les

 * generated today may <i>not</i> be readable by a binary that was compiled 6 months ago).
 *
 * <p>As of Guava 23.0, this class is thread-safe and lock-free. It internally uses atomics and
 * compare-and-swap to ensure correctness when multiple threads are used to access it.
 *
 * @param <T> the type of instances that the {@code BloomFilter} accepts
 * @author Dimitris Andreou
 * @author Kevin Bourrillion

  public void testCompare() {
    for (float x : VALUES) {
      for (float y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y)
            .that(Floats.compare(x, y))
            .isEqualTo(Float.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Floats.contains(EMPTY, (float) 1)).isFalse();

  }

  public void testCompare() {
    for (int x : VALUES) {
      for (int y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y)
            .that(Ints.compare(x, y))
            .isEqualTo(Integer.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Ints.contains(EMPTY, (int) 1)).isFalse();

  public void testCompare() {
    for (double x : VALUES) {
      for (double y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y)
            .that(Doubles.compare(x, y))
            .isEqualTo(Double.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Doubles.contains(EMPTY, (double) 1)).isFalse();

  public void testCompare() {
    for (float x : VALUES) {
      for (float y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y)
            .that(Floats.compare(x, y))
            .isEqualTo(Float.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Floats.contains(EMPTY, (float) 1)).isFalse();

  public void testCompare() {
    for (long x : VALUES) {
      for (long y : VALUES) {
        // note: spec requires only that the sign is the same
        assertWithMessage(x + ", " + y)
            .that(Longs.compare(x, y))
            .isEqualTo(Long.valueOf(x).compareTo(y));
      }
    }
  }

  public void testContains() {
    assertThat(Longs.contains(EMPTY, (long) 1)).isFalse();