* with the range (if any) that contains a specified key.
 *
 * <p>In contrast to {@link RangeSet}, no "coalescing" is done of {@linkplain
 * Range#isConnected(Range) connected} ranges, even if they are mapped to the same value.
 *
 * @author Louis Wasserman
 * @since 14.0
 */
@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989

            NEXT_HIGHER);
    if (ceilingIndex < ranges.size()
        && ranges.get(ceilingIndex).isConnected(otherRange)
        && !ranges.get(ceilingIndex).intersection(otherRange).isEmpty()) {
      return true;
    }
    return ceilingIndex > 0
        && ranges.get(ceilingIndex - 1).isConnected(otherRange)
        && !ranges.get(ceilingIndex - 1).intersection(otherRange).isEmpty();
  }

  @Override

     */
    @Override
    void close() throws CIFSException;

    /**
     * Checks whether the tree is currently connected
     * @return the tree is connected
     */
    boolean isConnected();

    /**
     * Gets the server timezone offset in milliseconds
     * @return server timezone offset
     * @throws CIFSException if an error occurs retrieving the timezone offset
     */

      boolean anyOverlaps = false;
      for (Range<Integer> range : subset) {
        boolean overlaps = false;
        for (Range<Integer> other : mutable.asRanges()) {
          if (other.isConnected(range) && !other.intersection(range).isEmpty()) {
            overlaps = true;
            anyOverlaps = true;
            break;
          }
        }

        try {

      for (int i = 0; i < entries.size(); i++) {
        Range<K> range = entries.get(i).getKey();
        if (i > 0) {
          Range<K> prevRange = entries.get(i - 1).getKey();
          if (range.isConnected(prevRange) && !range.intersection(prevRange).isEmpty()) {
            throw new IllegalArgumentException(
                "Overlapping ranges: range " + prevRange + " overlaps with entry " + range);
          }
        }

    protected void doCloseInternal() throws CIFSException {
        try {
            @SuppressWarnings("resource")
            final SmbTreeHandleImpl th = getTreeHandle();
            if (this.fileId != null && th.isConnected()) {
                th.send(new Smb2CloseRequest(th.getConfig(), this.fileId));
            }
        } finally {
            this.fileId = null;
        }
    }

      for (int i = 0; i < entries.size(); i++) {
        Range<K> range = entries.get(i).getKey();
        if (i > 0) {
          Range<K> prevRange = entries.get(i - 1).getKey();
          if (range.isConnected(prevRange) && !range.intersection(prevRange).isEmpty()) {
            throw new IllegalArgumentException(
                "Overlapping ranges: range " + prevRange + " overlaps with entry " + range);
          }
        }

    }

    /**
     * Check if connection is established and ready for use
     *
     * @return true if connection is connected/established, false otherwise
     */
    public boolean isConnected() {
        return state == RdmaConnectionState.CONNECTED || state == RdmaConnectionState.ESTABLISHED;
    }

    /**
     * Read data from RDMA connection
     *
     * @param buffer buffer to read data into

  RegularContiguousSet(Range<C> range, DiscreteDomain<C> domain) {
    super(domain);
    this.range = range;
  }

  private ContiguousSet<C> intersectionInCurrentDomain(Range<C> other) {
    return range.isConnected(other)
        ? ContiguousSet.create(range.intersection(other), domain)
        : new EmptyContiguousSet<C>(domain);
  }

  @Override
  ContiguousSet<C> headSetImpl(C toElement, boolean inclusive) {

     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#isValid()
     */
    @Override
    public boolean isValid() {
        return this.open && this.tree_num == this.tree.getTreeId() && this.tree.isConnected();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close(long)
     */
    @Override
    public synchronized void close(final long lastWriteTime) throws CIFSException {