final String plainValue = getFromCache(propertyKey);
                final String filteredValue = propertyFilter.filter(propertyKey, plainValue);
                verifyPropertyValue(propertyKey, filteredValue); // null checked
                return filterPropertyAsDefault(filteredValue); // not null here
            }

            private String getFromCache(final String propertyKey) {
                try {

  @SuppressWarnings("unchecked") // empty Object[] as E[]
  public static <E extends @Nullable Object> MinimalSet<E> of(E... contents) {
    return ofClassAndContents(Object.class, (E[]) new Object[0], asList(contents));
  }

  @SuppressWarnings("unchecked") // empty Object[] as E[]

  @SuppressWarnings("unchecked") // empty Object[] as E[]
  public static <E extends @Nullable Object> MinimalSet<E> of(E... contents) {
    return ofClassAndContents(Object.class, (E[]) new Object[0], asList(contents));
  }

  @SuppressWarnings("unchecked") // empty Object[] as E[]

      this.adder = adder;
    }

    @Override
    @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
    public int add(int a, int b) {
      try {
        return adder.add(a, b);
      } catch (Exception e) { // sneaky checked exception
        // swallow!
        return 0;
      }
    }

    @Override
    public String toString() {

   * safe range. If {@code safeMax < safeMin} then no code points are considered safe.
   *
   * <p>If a code point has no mapped replacement then it is checked against the safe range. If it
   * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed.
   *
   * @param replacementMap a map of characters to their escaped representations

        }
        return;
      }
    }
    fail(
        rootLocaleFormat(
            "Feature enum %s should contain an annotation named 'Require'.", featureEnumClass));
  }

  @SuppressWarnings("unchecked")
  private static Class<? extends Annotation> asAnnotation(Class<?> clazz) {
    if (clazz.isAnnotation()) {
      return (Class<? extends Annotation>) clazz;
    } else {

  }

  /**
   * Returns an iterable whose iterator returns the given elements in order. The elements are copied
   * out of the source collection at the time this method is called.
   */
  @SuppressWarnings("unchecked") // Es come in, Es go out
  public static <E extends @Nullable Object> MinimalIterable<E> from(Collection<E> elements) {
    return (MinimalIterable) of(elements.toArray());
  }

  private @Nullable Iterator<E> iterator;

          mapEntry("foo", 5),
          mapEntry("bar", 3),
          mapEntry("baz", 17),
          mapEntry("quux", 1),
          mapEntry("toaster", -2));
    }

    @SuppressWarnings("unchecked")
    @Override
    public Entry<String, Integer>[] createArray(int length) {
      return (Entry<String, Integer>[]) new Entry<?, ?>[length];
    }

    @Override

            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception
        // If logging fails, e.g. due to missing memory, at least try to log the
        // message and the cause for the failed logging.
        System.err.println(e.getMessage());

  // but types are typically only Comparable to themselves).
  @SuppressWarnings({"rawtypes", "unchecked"})
  private static MultimapBuilderWithKeys<Comparable<?>> rawtypeToWildcard(
      MultimapBuilderWithKeys<Comparable> treeKeys) {
    return (MultimapBuilderWithKeys) treeKeys;
  }

  @SuppressWarnings({"rawtypes", "unchecked"})
  private static <K extends @Nullable Object>