import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.Nullable;

/**
 * Static utility methods pertaining to {@link Queue} and {@link Deque} instances. Also see this
 * class's counterparts {@link Lists}, {@link Sets}, and {@link Maps}.
 *
 * @author Kurt Alfred Kluever
 * @since 11.0
 */
@GwtCompatible
public final class Queues {
  private Queues() {}

  // ArrayBlockingQueue

  /**

     *
     * @return true if RDMA can be used, false otherwise
     */
    boolean isAvailable();

    /**
     * Get supported RDMA capabilities
     *
     * @return set of capabilities supported by this provider
     */
    Set<RdmaCapability> getSupportedCapabilities();

    /**
     * Create RDMA connection to remote endpoint
     *
     * @param remote remote socket address

      }

      // don't try to remove the set if it's empty; that can't be done safely without a lock
      // anyway, if the set is empty it'll just be wrapping an array of length 0
    }
  }

  @VisibleForTesting
  Set<Subscriber> getSubscribersForTesting(Class<?> eventType) {

  // This is needed when resolving types against a context with wildcards
  // For example:
  // class Holder<T> {
  //   void set(T data) {...}
  // }
  // Holder<List<?>> should *not* resolve the set() method to set(List<?> data).
  // Instead, it should create a capture of the wildcard so that set() rejects any List<T>.
  private static class WildcardCapturer {

    static final WildcardCapturer INSTANCE = new WildcardCapturer();

        ALLOWS_NULL_KEYS);
  }

  /**
   * Map generator that verifies that {@code setUp()} methods are called in all the test cases. The
   * {@code setUpRan} parameter is set true by the {@code setUp} that every test case is supposed to
   * have registered, and set false by the {@code tearDown}. We use a dynamic proxy to intercept all
   * of the {@code Map} method calls and check that {@code setUpRan} is true.
   */

  public void putAll(Map<? extends K, ? extends V> map) {
    delegate().putAll(map);
  }

  @Override
  public Set<K> keySet() {
    return delegate().keySet();
  }

  @Override
  public Collection<V> values() {
    return delegate().values();
  }

  @Override
  public Set<Entry<K, V>> entrySet() {
    return delegate().entrySet();
  }

  @Override

   * java.util.Collections#emptySet}
   */
  NONE;

  private final Set<Feature<? super Collection>> implied;

  CollectionFeature(Feature<? super Collection>... implied) {
    this.implied = copyToSet(implied);
  }

  @Override
  public Set<Feature<? super Collection>> getImpliedFeatures() {
    return implied;
  }

  @Retention(RetentionPolicy.RUNTIME)

     * @param objs the log objects (should contain UrlQueue and Set of RequestData)
     */
    protected void processProcessChildUrlsByException(final Object... objs) {
        // CrawlerContext crawlerContext = (CrawlerContext) objs[0];
        final UrlQueue<?> urlQueue = (UrlQueue<?>) objs[1];
        @SuppressWarnings("unchecked")
        final Set<RequestData> requestDataSet = (Set<RequestData>) objs[2];
        if (logger.isDebugEnabled()) {

            if (matcher.matches()) {
                return entry.getValue();
            }
        }
        return null;
    }

    /**
     * Sets the initialization parameter map for all clients.
     * @param params The map of parameters.
     */
    public void setInitParameterMap(final Map<String, Object> params) {
        if (params != null) {

     *
     * @return A <code>String</code> containing the supplied domain.
     */
    public String getSuppliedDomain() {
        return suppliedDomain;
    }

    /**
     * Sets the supplied authentication domain for this message.
     *
     * @param suppliedDomain The supplied domain for this message.
     */
    public void setSuppliedDomain(final String suppliedDomain) {