}
  }

  @LazyInit private transient @Nullable Collection<V> values;

  @Override
  public Collection<V> values() {
    Collection<V> result = values;
    return (result == null) ? values = createValues() : result;
  }

  Collection<V> createValues() {
    return new Values();
  }

  Iterator<V> valuesIterator() {

      assertThat(values).hasSize(WARMUP_SIZE);
      for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) {
        Object value = warmed.get(i - WARMUP_MIN).getValue();
        assertThat(values.contains(value)).isTrue();
        assertThat(values.remove(value)).isTrue();
        assertThat(values.remove(value)).isFalse();
        assertThat(values.contains(value)).isFalse();
      }
      checkEmpty(values);
      checkEmpty(cache);

    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,

   * to {@link LoadingCache#get} if this method is not overridden.
   *
   * @param keys the unique, non-null keys whose values should be loaded
   * @return a map from each key in {@code keys} to the value associated with that key; <b>may not
   *     contain null values</b>
   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is

   */
  @InlineMe(replacement = "Character.hashCode(value)")
  @InlineMeValidationDisabled(
      "The hash code of a char is the int version of the char itself, so it's simplest to return"
          + " that.")
  public static int hashCode(char value) {
    return value;
  }

  /**
   * Returns the {@code char} value that is equal to {@code value}, if possible.
   *

  // in the short hash. We saw that a mask of 0x7f would keep the 7-bit value 0x6f from a full
  // hashcode of 0x89abcdef. The imaginary `hash` value would then be the remaining top 25 bits,
  // 0x89abcd80. To this is added (or'd) the `next` value, which is an index within `entries`
  // (and therefore within `keys` and `values`) of another entry that has the same short hash

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

            final String[] values = entry.getValue().split(",");
            for (final String value : values) {
                putResultDataWithTemplate(dataMap, key, metaDataMap.get(value), scriptConfigMap.get(key), scriptType);
            }
        }
        final Map<String, String> valueConfigMap = crawlingConfig.getConfigParameterMap(ConfigName.VALUE);

            return null;
        }

        final String[] values = header.split(" ");
        if (values.length != 2) {
            return null;
        }

        final String path;
        if (values[1].startsWith("/")) {
            path = values[1];
        } else {
            path = "/" + values[1];
        }

        final CurlHelper curlHelper = ComponentUtil.getCurlHelper();

        if (values == null || values.isEmpty()) {
            String msg = "Cannot register null or empty query collection: name=" + name + " values=" + values;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    // ===================================================================================