* at {@link ImmutableCollection}.
 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V> implements BiMap<K, V> {

  /**
   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableBiMap} whose keys
   * and values are the result of applying the provided mapping functions to the input elements.

import org.opensearch.transport.client.Client;

import jakarta.annotation.PreDestroy;

/**
 * FesenClient is a client for OpenSearch.
 *
 * @author shinsuke
 *
 */
public class FesenClient implements Client {
    /**
     * HTTP address for OpenSearch.
     */
    public static final String HTTP_ADDRESS = "crawler.opensearch.http_address";

    /**
     * Target indices for OpenSearch.
     */

        void testUnwrapToIncompatibleType() {
            // Create a mock class that extends DfsReferralData but is not compatible
            class IncompatibleReferralData implements DfsReferralData {
                @Override
                public <T extends DfsReferralData> T unwrap(Class<T> type) {
                    return null;
                }

                @Override

        assertEquals(expected, ImmutableList.copyOf(misleading));
        assertEquals(expected, ImmutableList.copyOf((Iterable<String>) misleading));
      }
    }
  }

  private static class CountingIterable implements Iterable<String> {
    int count = 0;

    @Override
    public Iterator<String> iterator() {
      count++;
      return asList("a", "b", "a").iterator();
    }
  }

 * with maven-shared-utils, while Maven has migrated to JLine (into which Jansi has been merged
 * since JLine 3.25.0).
 */
@Deprecated
@SuppressWarnings("unused")
public class Ansi implements Appendable {

    private static final char FIRST_ESC_CHAR = 27;
    private static final char SECOND_ESC_CHAR = '[';

    /**

 *
 * @author Cliff L. Biffle
 * @author mike nonemacher
 * @since 2.0
 */
@J2ktIncompatible
@GwtIncompatible
public final class ConcurrentHashMultiset<E> extends AbstractMultiset<E> implements Serializable {

  /*
   * The ConcurrentHashMultiset's atomic operations are implemented primarily in terms of
   * AtomicInteger's atomic operations, with some help from ConcurrentMap's atomic operations on

// just to do everything we can to emphasize the "practically an interface" nature of this class.
public abstract class ImmutableCollection<E> extends AbstractCollection<E> implements Serializable {
  /*
   * We expect SIZED (and SUBSIZED, if applicable) to be added by the spliterator factory methods.
   * These are properties of the collection as a whole; SIZED and SUBSIZED are more properties of

            throw new JobProcessingException(e);
        }
    }

    /**
     * File visitor for purging old thumbnail files.
     */
    protected static class FilePurgeVisitor implements FileVisitor<Path> {

        /**
         * Expiry time threshold for file deletion.
         */
        protected final long expiry;

        /**
         * Count of processed files.
         */

   * that {@link #get} calls exactly the implementation of {@link AbstractFuture#get}.
   */
  abstract static class TrustedFuture<V extends @Nullable Object> extends FluentFuture<V>
      implements AbstractFuture.Trusted<V> {
    @CanIgnoreReturnValue
    @Override
    @ParametricNullness
    public final V get() throws InterruptedException, ExecutionException {
      return super.get();
    }

import org.apache.maven.repository.legacy.resolver.conflict.ConflictResolver;
import org.codehaus.plexus.logging.Logger;

/**
 */
@Named
@Singleton
@Deprecated
public class DefaultLegacyArtifactCollector implements LegacyArtifactCollector {

    @Inject
    @Named("nearest")
    private ConflictResolver defaultConflictResolver;

    @Inject
    private Logger logger;

    @Inject