@Override
  public Set<T> asSet() {
    return Collections.singleton(reference);
  }

  @Override
  public <V> Optional<V> transform(Function<? super T, V> function) {
    return new Present<>(
        checkNotNull(
            function.apply(reference),
            "the Function passed to Optional.transform() must not return null."));
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof Present) {

 *
 *
 */
@Deprecated
public interface ClasspathTransformation {
    String ROLE = ClasspathTransformation.class.getName();

    /**
     * Transform Graph into a Collection of metadata objects that
     * could serve as a classpath for a particular scope
     *
     * @param dirtyGraph - dependency graph
     * @param scope - which classpath to extract

        <constraint name="__context__" within="" contains="" />

   *
   * @param q the blocking queue to be drained
   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */

 * limitations under the License.
 */

package gradlebuild.binarycompatibility.rules

import gradlebuild.binarycompatibility.metadata.KotlinMetadataQueries
import groovy.transform.CompileStatic
import japicmp.model.JApiCompatibility
import japicmp.model.JApiMethod
import me.champeau.gradle.japicmp.report.Violation

@CompileStatic

        Entry<String, String> entry = (Entry<String, String>) o;
        multimap.put(entry.getKey(), Ascii.toUpperCase(entry.getValue()));
      }
      return transform(multimap);
    }

    abstract M transform(Multimap<String, String> multimap);

    @SuppressWarnings("unchecked")
    @Override
    public Entry<String, String>[] createArray(int length) {

            it.isNotEmpty()
        }

        if (mismatches.isNotEmpty()) {
            val formattedMismatches = mismatches.mapValues { mismatch ->
                mismatch.value.joinToString(separator = "\n", transform = { "\t" + it })
            }
            throw GradleException(buildErrorMessage(formattedMismatches))
        }
    }

    private

              return Iterators.unmodifiableIterator(
                  Iterators.concat(
                      Iterators.transform(
                          graph.predecessors(node).iterator(),
                          (N predecessor) -> EndpointPair.ordered(predecessor, node)),
                      Iterators.transform(
                          // filter out 'node' from successors (already covered by predecessors,

 *
 * {@snippet :
 * ListenableFuture<Boolean> adminIsLoggedIn =
 *     FluentFuture.from(usersDatabase.getAdminUser())
 *         .transform(User::getId, directExecutor())
 *         .transform(ActivityService::isLoggedIn, threadPool)
 *         .catching(RpcException.class, e -> false, directExecutor());
 * }
 *
 * <h3>Alternatives</h3>
 *
 * <h4>Frameworks</h4>
 *

              "html",
              "io",
              "math",
              "net",
              "primitives",
              "reflect",
              "util.concurrent",
              "xml")
          .transform("com.google.common."::concat)
          .toSet();

  public void testClassesHaveOverrides() throws Exception {
    for (ClassInfo info : ClassPath.from(getClass().getClassLoader()).getAllClasses()) {