url: https://github.com/BoostryJP
  - login: requestly
    avatarUrl: https://avatars.githubusercontent.com/u/12287519?v=4
    url: https://github.com/requestly
  - login: acsone
    avatarUrl: https://avatars.githubusercontent.com/u/7601056?v=4
    url: https://github.com/acsone
- - login: scalar
    avatarUrl: https://avatars.githubusercontent.com/u/301879?v=4
    url: https://github.com/scalar
  - login: Trivie

  override fun setSSLParameters(p: SSLParameters) {
    delegate!!.sslParameters = p
  }

  @Throws(IOException::class)
  override fun close() {
    delegate!!.close()
  }

  override fun getInetAddress(): InetAddress = delegate!!.inetAddress

  @Throws(IOException::class)
  override fun getInputStream(): InputStream = delegate!!.inputStream

      builder.eventListenerFactory(LoggingEventListener.Factory(logger))
    }
    return builder.build()
  }

  fun close() {
    val okHttpClient = client as OkHttpClient
    okHttpClient.connectionPool.evictAll() // Close any persistent connections.
    okHttpClient.dispatcher.executorService.shutdownNow()
  }

  companion object {
    internal const val NAME = "okcurl"

                // Continue with destruction even if listener fails
            }
        }

        // Close the object if it implements AutoCloseable or Closeable
        final T obj = p.getObject();
        if (obj instanceof AutoCloseable) {
            try {
                ((AutoCloseable) obj).close();
            } catch (final Exception e) {

            final ObjectOutputStream oos = new ObjectOutputStream(baos);
            try {
                oos.writeObject(obj);
            } finally {
                oos.close();
            }
            return baos.toByteArray();
        } catch (final IOException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**

        throw new IOException("Failed to reconnect durable handle");
    }
}

@Override
public void close() throws IOException {
    try {
        // Normal close operations
        super.close();
    } finally {
        // Don't release durable handle on close if it's persistent
        if (handleManager != null && handleType != HandleType.PERSISTENT) {

 */

package jcifs.smb1.smb1;

import jcifs.smb1.Config;

class SmbComReadAndX extends AndXServerMessageBlock {

    private static final int BATCH_LIMIT = Config.getInt("jcifs.smb1.smb.client.ReadAndX.Close", 1);

    private long offset;
    private int fid;

    private final int openTimeout;
    int maxCount, minCount, remaining;

    SmbComReadAndX() {
        super(null);

            new SystemLogger(stdErr).error(e.getMessage(), e);
            return 1;
        } finally {
            if (classWorldManaged) {
                classWorld.close();
            }
        }
    }

    protected MessageBuilderFactory createMessageBuilderFactory() {
        return new JLineMessageBuilderFactory();
    }

    protected abstract Invoker createInvoker();

                session.getRequest().getDegreeOfConcurrency(),
                session.getProjects().size());
        boolean parallel = nThreads > 1;
        // Propagate the parallel flag to the root session and all the cloned sessions in each project segment
        session.setParallel(parallel);
        for (ProjectSegment segment : projectBuilds) {
            segment.getSession().setParallel(parallel);
        }

     */
    @Nonnull
    Optional<ClassLoader> currentThreadClassLoader();

    /**
     * Performs a clean shutdown of backing container.
     */
    @Override
    void close() throws Exception;