*       as that of its keys. This is sometimes called an "invertible map," since the restriction on
 *       values enables it to support an {@linkplain BiMap#inverse inverse view} -- which is another
 *       instance of {@code BiMap}.
 *   <dt>{@link Table}
 *   <dd>A new type, which is similar to {@link java.util.Map}, but which indexes its values by an

 *       as that of its keys. This is sometimes called an "invertible map," since the restriction on
 *       values enables it to support an {@linkplain BiMap#inverse inverse view} -- which is another
 *       instance of {@code BiMap}.
 *   <dt>{@link Table}
 *   <dd>A new type, which is similar to {@link java.util.Map}, but which indexes its values by an

  }

  /**
   * Returns the total number of times that {@link Cache} lookup methods attempted to load new
   * values. This includes both successful load operations and those that threw exceptions. This is
   * defined as {@code loadSuccessCount + loadExceptionCount}.
   *
   * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is

    }
  }

  private final transient ImmutableList<Range<K>> ranges;
  private final transient ImmutableList<V> values;

  ImmutableRangeMap(ImmutableList<Range<K>> ranges, ImmutableList<V> values) {
    this.ranges = ranges;
    this.values = values;
  }

  @Override
  public @Nullable V get(K key) {
    int index =
        SortedLists.binarySearch(
            ranges,

    for (Entry<K, V> entry : entries) {
      resetContainer();
      K k = entry.getKey();
      V v = entry.getValue();

      Set<V> values = multimap().get(k);
      Set<V> expectedValues = copyToSet(values);

      assertFalse(multimap().put(k, v));
      assertEquals(expectedValues, values);
      assertGet(k, expectedValues);
    }
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})

    public void setAvailable_PercentileRanks(double[] values) {
        setAvailable_PercentileRanks(values, null);
    }

    public void setAvailable_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setAvailable_PercentileRanks("available", values, opLambda);
    }

    public void setAvailable_PercentileRanks(String name, double[] values,

#### Get the *enumeration value* { #get-the-enumeration-value }

You can get the actual value (a `str` in this case) using `model_name.value`, or in general, `your_enum_member.value`:

{* ../../docs_src/path_params/tutorial005.py hl[20] *}

/// tip

You could also access the value `"lenet"` with `ModelName.lenet.value`.

///

      unmodifiableList(Arrays.<@Nullable Integer>asList(null, 1, 2, 3, 4, 5));

  public void testCreateEmptyRangeFails() {
    for (BoundType lboundType : BoundType.values()) {
      for (BoundType uboundType : BoundType.values()) {
        assertThrows(
            IllegalArgumentException.class,
            () -> GeneralRange.range(ORDERING, 4, lboundType, 2, uboundType));
      }
    }
  }

    getMap().keySet().remove(k0());
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveFromValuesRemovesFromInverse() {
    getMap().values().remove(v0());
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveFromInverseRemovesFromForward() {

                .of(stream -> stream.filter(StringUtil::isNotBlank).forEach(s -> {
                    final String[] values = StringUtils.split(s, "=", 2);
                    if (values.length == 2) {
                        mimetypeMap.put(values[0], values[1]);
                    }
                }));
        if (logger.isDebugEnabled()) {
            logger.debug("loaded filetype: {}", mimetypeMap);