* @param rootCause the cause of this exception
     */
    public TransportException(final String msg, final Throwable rootCause) {
        super(msg, rootCause);
    }

    /**
     * Gets the root cause of this exception.
     * @return root cause of this exception
     */
    @Deprecated
    public Throwable getRootCause() {
        return getCause();
    }

         * <p>
         * This method works in conjunction with the filtering in executePlan():
         * - For FAIL_FAST: Sets ReactorBuildStatus to halted, which causes executePlan to only process after:* steps
         * - For FAIL_AT_END: Blacklists the project and its dependents, which causes executePlan to skip them
         * - For FAIL_NEVER: Does nothing special, allowing all projects to continue building
         * <p>

          return Optional.absent();
        }
        result += sizeIfKnown.get();
        if (result < 0) {
          // Overflow (or one or more sources that returned a negative size, but all bets are off in
          // that case)
          // Can't represent anything higher, and realistically there probably isn't anything that
          // can actually be done anyway with the supposed 8+ exbibytes of data the source is

@NullMarked
public final class SerializableTester {
  private SerializableTester() {}

  /**
   * Serializes and deserializes the specified object.
   *
   * <p><b>GWT warning:</b> Under GWT, this method simply returns its input, as proper GWT
   * serialization tests require more setup. This no-op behavior allows test authors to intersperse
   * {@code SerializableTester} calls with other, GWT-compatible tests.
   *

import java.util.Collections;
import java.util.Iterator;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A utility for testing an Iterator implementation by comparing its behavior to that of a "known
 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link

import java.util.stream.Stream;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * {@link Set} implementation that asserts that a given lock is held whenever one of its methods is
 * called.
 */
@NullUnmarked
class LockHeldAssertingSet<E> extends ForwardingSet<E> implements Serializable {
  final Set<E> delegate;
  final Object mutex;

 * RegularImmutableBiMap}, which don't have to recopy the entries created by their {@code Builder}
 * implementations.
 *
 * <p>This base implementation has no key or value pointers, so instances of ImmutableMapEntry (but
 * not its subclasses) can be reused when copied from one ImmutableMap to another.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible // unnecessary
class ImmutableMapEntry<K, V> extends SimpleImmutableEntry<K, V> {
  /**

<?xml version="1.0" encoding="UTF-8"?>
<metadata>
  <groupId>org.apache.maven.its</groupId>
  <artifactId>b</artifactId>
  <version>0.1</version>
  <versioning>
    <versions>
      <version>0.1</version>
    </versions>
    <lastUpdated>20091023222817</lastUpdated>
  </versioning>

Directory for library extension

If you use a database that DBFlute does not have its JDBC driver,
put your own JDBC driver for the database here.

  }

  /**
   * Override to return a chaining listenableFuture that returns the result of getSuccessfulResult()
   * when inputFuture returns VALID_INPUT_DATA, and sets the exception to EXCEPTION in all other
   * cases.
   */
  protected abstract ListenableFuture<T> buildChainingFuture(ListenableFuture<Integer> inputFuture);

  /**