this.treeHandle = th.acquire();
        try {
            this.next = open();
            if (this.next == null) {
                doClose();
            }
        } catch (final Exception e) {
            doClose();
            throw e;
        }

    }

    /**
     * Gets the SMB tree handle for this iterator.
     *
     * @return the treeHandle
     */

     *
     * @see jcifs.CloseableIterator#close()
     */
    @Override
    public void close() throws CIFSException {
        if (this.next != null) {
            doClose();
        }
    }

    /**
     *
     */
    private void doClose() {
        this.treeHandle.release();
        this.next = null;
    }

    @Override
    public void remove() {

                // this simply indicates an empty listing
                doClose();
                return null;
            }

            throw e;
        }
        this.fileId = createResp.getFileId();
        this.response = query.getResponse();
        final FileEntry n = advance(false);
        if (n == null) {
            doClose();
        }
        return n;
    }

    /**

                doClose();
                return null;
            }
            throw e;
        }

        this.response.setSubCommand(SmbComTransaction.TRANS2_FIND_NEXT2);
        final FileEntry n = advance(false);
        if (n == null) {
            doClose();
        }
        return n;
    }

    /**
     * {@inheritDoc}
     *

    val connection = this.connection
    if (connection != null) {
      connection.assertLockNotHeld()
      val toClose: Socket? =
        connection.withLock {
          // Sets this.connection to null.
          releaseConnectionNoEvents()
        }
      if (this.connection == null) {
        toClose?.closeQuietly()
        eventListener.connectionReleased(this, connection)

        // Cleanup first
        cleanup();
        log.debug("Closing pool");

        // Create a snapshot of connections to close
        List<SmbTransportImpl> toClose = new ArrayList<>(this.connections);
        toClose.addAll(this.nonPooledConnections);

        // Clear the collections (thread-safe operations)
        this.connections.clear();
        this.nonPooledConnections.clear();

    return optional.isPresent() ? DoubleStream.of(optional.getAsDouble()) : DoubleStream.empty();
  }

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private static void closeAll(BaseStream<?, ?>[] toClose) {
    // If one of the streams throws an exception, continue closing the others, then throw the
    // exception later. If more than one stream throws an exception, the later ones are added to the