// Signal that we are reconnected, update state and handle messages.
	// Prevent other connections from connecting while we process.
	c.reconnectMu.Lock()
	if c.remoteID != nil {
		c.reconnected()
	}
	rid := uuid.UUID(req.ID)
	c.remoteID = &rid

	// Handle incoming messages until disconnect.
	c.handleMessages(ctx, conn)
	return nil
}

// reconnected signals the connection has been reconnected.

        HandleReconnector reconnector = new HandleReconnector(handleManager);
        try {
            SmbFile reconnected = reconnector.reconnectHandle(this, e).get(5, TimeUnit.SECONDS);
            // Update this file's state from reconnected file
            this.fileId = reconnected.fileId;
        } catch (Exception reconnectError) {
            log.error("Failed to reconnect durable handle", reconnectError);

        .execute(() -> {
            try {
                transport.disconnect();
                transport.connect();  // Reconnect
                log.info("Successfully reconnected after witness notification");
            } catch (Exception e) {
                log.error("Failed to reconnect after witness notification", e);
            }
        });
}

private void scheduleAddressChange(InetAddress newAddress) {

            log.error("Failed to perform emergency tree cleanup", e);
        }
    }

    /**
     *
     * @return whether the tree is connected
     */
    public boolean isConnected() {
        return this.tid != -1 && this.session.isConnected() && this.connectionState.get() == 2;
    }

    /**
     * @return the type of this tree
     */
    public int getTreeType() {

    assertTrue(Range.closed(3, 5).isConnected(Range.open(5, 6)));
    assertTrue(Range.closed(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(5, 6).isConnected(Range.closed(3, 5)));
    assertTrue(Range.closed(3, 5).isConnected(Range.openClosed(5, 5)));
    assertTrue(Range.open(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(3, 7).isConnected(Range.open(6, 8)));

        when(tree.getTreeId()).thenReturn(11L);
        assertFalse(h.isValid());

        // Connected=false makes it invalid
        when(tree.getTreeId()).thenReturn(10L);
        when(tree.isConnected()).thenReturn(false);
        assertFalse(h.isValid());

        // Mark closed makes it invalid
        when(tree.isConnected()).thenReturn(true);
        assertTrue(h.isValid());
        h.markClosed();

func (c *Client) Close() {
	atomic.StoreInt32(&c.connected, closed)
}

// NewClient - returns new REST client.
func NewClient(uu *url.URL, tr http.RoundTripper, auth func() string) *Client {
	connected := int32(online)
	urlStr := uu.String()
	u, err := url.Parse(urlStr)
	if err != nil {
		// Mark offline, with no reconnection attempts.
		connected = int32(offline)
		err = &url.Error{URL: urlStr, Err: err}
	}

/**
 * A set comprising zero or more {@linkplain Range#isEmpty nonempty}, {@linkplain
 * Range#isConnected(Range) disconnected} ranges of type {@code C}.
 *
 * <p>Implementations that choose to support the {@link #add(Range)} operation are required to
 * ignore empty ranges and coalesce connected ranges. For example:
 *
 * {@snippet :
 * RangeSet<Integer> rangeSet = TreeRangeSet.create();

    assertTrue(Range.closed(3, 5).isConnected(Range.open(5, 6)));
    assertTrue(Range.closed(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(5, 6).isConnected(Range.closed(3, 5)));
    assertTrue(Range.closed(3, 5).isConnected(Range.openClosed(5, 5)));
    assertTrue(Range.open(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(3, 7).isConnected(Range.open(6, 8)));

     */
    @SuppressWarnings("resource")
    public synchronized boolean isConnected() {
        final SmbTreeImpl t = getTreeInternal();
        return t != null && t.isConnected();
    }

    /**
     *
     * @param loc
     * @param host
     * @return tree handle
     * @throws IOException
     */