import org.apache.maven.api.annotations.Nullable;

/**
 * An XML reader request.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface XmlReaderRequest {

    @Nullable
    Path getPath();

    @Nullable
    Path getRootDirectory();

    @Nullable
    URL getURL();

    @Nullable
    InputStream getInputStream();

    @Nullable
    Reader getReader();

    @Nullable

 *
 * @author Louis Wasserman
 */
@GwtCompatible
abstract class AbstractSortedKeySortedSetMultimap<
        K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractSortedSetMultimap<K, V> {

  AbstractSortedKeySortedSetMultimap(SortedMap<K, Collection<V>> map) {
    super(map);
  }

  @Override
  public SortedMap<K, Collection<V>> asMap() {

      // There is no StackOverflowError under GWT/J2CL.
      throw (Error) t;
    }
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future)
      throws InterruptedException, ExecutionException {
    return future.getFromAlreadyDoneTrustedFuture();
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future, long timeout, TimeUnit unit)

                mergeFunction),
        (s1, s2) -> s1.combine(s2, mergeFunction),
        state -> state.toTable());
  }

  static <
          T extends @Nullable Object,
          R extends @Nullable Object,
          C extends @Nullable Object,
          V,
          I extends Table<R, C, V>>
      Collector<T, ?, I> toTable(
          Function<? super T, ? extends R> rowFunction,

   */
  public static <A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      Function<A, C> compose(Function<B, C> g, Function<A, ? extends B> f) {
    return new FunctionComposition<>(g, f);
  }

  private static final class FunctionComposition<
          A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      implements Function<A, C>, Serializable {

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Test cases for a {@link Table} implementation supporting reads and writes.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public abstract class AbstractTableTest<C extends @Nullable Character>
    extends AbstractTableReadTest<C> {

   */

  public static <V extends @Nullable Object> ListenableFuture<V> catching(
      ListenableFuture<? extends V> input,
      Class<Throwable> exceptionType,
      Function<? super Throwable, ? extends V> fallback,
      Executor executor) {
    return AbstractCatchingFuture.create(input, exceptionType, fallback, executor);
  }

  public static <V extends @Nullable Object> ListenableFuture<V> catchingAsync(

  }

  /**
   * Class for testing all permutations of nullable/non-nullable two-argument methods using
   * testMethod().
   *
   * <ul>
   *   <li>normalNormal: two params, neither is Nullable
   *   <li>nullableNormal: only first param is Nullable
   *   <li>normalNullable: only second param is Nullable
   *   <li>nullableNullable: both params are Nullable
   * </ul>
   */
  public static class TwoArg {

     */
    @Deprecated(since = "4.0.0", forRemoval = true)
    @Nullable
    static XmlNode merge(@Nullable XmlNode dominant, @Nullable XmlNode recessive) {
        return XmlService.merge(dominant, recessive, null);
    }

    @Nullable
    static XmlNode merge(
            @Nullable XmlNode dominant, @Nullable XmlNode recessive, @Nullable Boolean childMergeOverride) {

    super(cause);
  }

  public UncheckedTimeoutException(@Nullable String message, @Nullable Throwable cause) {
    super(message, cause);
  }

  private static final long serialVersionUID = 0;