*
     * @param <T> the element type
     * @param iterable the iterable (must not be {@literal null})
     * @return an {@link Iterable} wrapping an {@link IndexedIterator}
     */
    public static <T> Iterable<Indexed<T>> indexed(final Iterable<T> iterable) {
        assertArgumentNotNull("iterable", iterable);
        return indexed(iterable.iterator());
    }

    /**

     * @return the normalized encoding or the default encoding if the input is blank
     */
    public String normalize(final String enc) {
        if (StringUtil.isBlank(enc)) {
            return defaultEncoding;
        }

        final String newEnc = encodingMap.get(toLowerCase(enc));
        if (StringUtil.isBlank(newEnc)) {
            return enc;
        }
        return newEnc;
    }

        System.arraycopy(bos.toByteArray(), 0, dst, dstIndex, bos.size());
        return bos.size();
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

     * Gets the Fess configuration instance.
     *
     * @return the Fess configuration
     */
    @Override
    public FessConfig getFessConfig() {
        return fessConfig;
    }

    /**
     * Gets the logger instance for this transformer.
     *
     * @return the logger instance
     */
    @Override
    public Logger getLogger() {
        return logger;
    }

    /**

        serveConnection(nextConnectionIndex++, socket, peek)
      }
    }
  }

  public override fun close() {
    if (closed) return
    closed = true

    if (!started) return // Nothing to shut down.
    val serverSocket = this.serverSocket ?: return // If this is null, start() must have failed.

    // Cause acceptConnections() to break out.
    serverSocket.closeQuietly()

    // Await shutdown.

    @Override
    protected Set<T> delegate() {
      return backingSet;
    }

    @Override
    public boolean equals(@Nullable Object object) {
      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public boolean addAll(Collection<? extends T> collection) {
      return standardAddAll(collection);
    }

    @Override

      Object unused = digest.clone();
      return true;
    } catch (CloneNotSupportedException e) {
      return false;
    }
  }

  @Override
  public int bits() {
    return bytes * Byte.SIZE;
  }

  @Override
  public String toString() {
    return toString;
  }

  private static MessageDigest getMessageDigest(String algorithmName) {
    try {
      return MessageDigest.getInstance(algorithmName);

      check(!closed) { "closed" }
      if (inputExhausted) return -1

      val read = super.read(sink, byteCount)
      if (read == -1L) {
        inputExhausted = true
        responseBodyComplete(trailers = Headers.EMPTY)
        return -1
      }
      return read
    }

    override fun close() {
      if (closed) return
      if (!inputExhausted) {

     * @param path the file path
     * @return the handle info or null if not found
     */
    public HandleInfo getHandleByPath(String path) {
        lock.readLock().lock();
        try {
            return handles.get(path);
        } finally {
            lock.readLock().unlock();
        }
    }

    /**
     * Get the number of active handles
     * @return the number of handles
     */

            return calledName;
        }
        return null;
    }

    /**
     * Return the underlying <code>NbtAddress</code> or {@code InetAddress}.
     *
     * @return the underlying address object
     */

    public Object getAddress() {
        return addr;
    }

    /**
     * Return the hostname of this address such as "MYCOMPUTER".
     *