ListenableFuture<@Nullable Void> unused = serializer.submit(blockingCallable, executor);
    ListenableFuture<Boolean> future2 =
        serializer.submit(
            new Callable<Boolean>() {
              @Override
              public Boolean call() {
                return blockingCallable.isRunning();
              }
            },
            directExecutor());

    /**
     * Total number of pages.
     */
    private int allPageCount;

    /**
     * Flag indicating if a previous page exists.
     */
    private boolean existPrePage;

    /**
     * Flag indicating if a next page exists.
     */
    private boolean existNextPage;

    /**
     * List of page numbers for pagination.
     */
    private List<Integer> pageNumberList;

    /**

    private final ConcurrentHashMap<String, FileInfo> children;
    private final ReadWriteLock lock;
    
    // Cache metadata
    private volatile boolean isComplete;  // True if full enumeration cached
    private volatile boolean hasChanges;  // True if changes detected
    private DirectoryCacheScope scope;
    private long maxAge;
    

  /** If true we should convert space to the {@code +} character. */
  private final boolean plusForSpace;

  /**
   * An array of flags where for any {@code char c} if {@code safeOctets[c]} is true then {@code c}
   * should remain unmodified in the output. If {@code c >= safeOctets.length} then it should be
   * escaped.
   */
  private final boolean[] safeOctets;

  /**

    return previousSuccessor == null ? null : (V) previousSuccessor;
  }

  private static boolean isPredecessor(@Nullable Object value) {
    return (value == PRED) || (value instanceof PredAndSucc);
  }

  private static boolean isSuccessor(@Nullable Object value) {
    return (value != PRED) && (value != null);
  }

                return Byte.valueOf(new SimpleDateFormat(pattern).format(o));
            }
            return (byte) ((java.util.Date) o).getTime();
        } else if (o instanceof Boolean) {
            return ((Boolean) o) ? (byte) 1 : (byte) 0;
        } else {
            return toByte(o.toString());
        }
    }

    private static Byte toByte(final String s) {
        if (StringUtil.isEmpty(s)) {

            String id, String url, String layoutId, boolean uniqueVersion) throws UnknownRepositoryLayoutException {
        return injectSession(factory.createDeploymentArtifactRepository(id, url, layoutId, uniqueVersion), false);
    }

    @Override
    public ArtifactRepository createDeploymentArtifactRepository(
            String id, String url, ArtifactRepositoryLayout repositoryLayout, boolean uniqueVersion) {
        return injectSession(

    }

    @Override
    ImmutableSortedSet<C> headSetImpl(C toElement, boolean inclusive) {
      return subSet(Range.upTo(toElement, BoundType.forBoolean(inclusive)));
    }

    @Override
    ImmutableSortedSet<C> subSetImpl(
        C fromElement, boolean fromInclusive, C toElement, boolean toInclusive) {
      if (!fromInclusive && !toInclusive && Range.compareOrThrow(fromElement, toElement) == 0) {

      .url("https://doh.crypto.sx/dns-query".toHttpUrl())
      .includeIPv6(false)
      .build()

  @JvmStatic
  fun providers(
    client: OkHttpClient,
    http2Only: Boolean,
    workingOnly: Boolean,
    getOnly: Boolean,
  ): List<DnsOverHttps> =
    buildList {
      add(buildGoogle(client))
      if (!getOnly) {
        add(buildGooglePost(client))
      }
      add(buildCloudflare(client))

        READ,
        /** RDMA write operation */
        WRITE
    }

    private final long requestId;
    private final RequestType type;
    private final RdmaMemoryRegion memoryRegion;
    private volatile boolean completed;
    private volatile Exception error;

    /**
     * Create new RDMA work request
     *
     * @param requestId unique request identifier
     * @param type type of request