return method.getName().startsWith("enter") || method.getName().startsWith("tryEnter");
  }

  /** Identifies just tryEnterXxx methods (a subset of {@link #isAnyEnter}), which never block. */
  private static boolean isTryEnter(Method method) {
    return method.getName().startsWith("tryEnter");
  }

  /**

 * that provide readers that are:
 *
 * <ul>
 *   <li><b>Finite:</b> Many operations, such as {@link #length()} and {@link #read()}, will either
 *       block indefinitely or fail if the source creates an infinite reader.
 *   <li><b>Non-destructive:</b> A <i>destructive</i> reader will consume or otherwise alter the

 * that provide streams that are:
 *
 * <ul>
 *   <li><b>Finite:</b> Many operations, such as {@link #size()} and {@link #read()}, will either
 *       block indefinitely or fail if the source creates an infinite stream.
 *   <li><b>Non-destructive:</b> A <i>destructive</i> stream will consume or otherwise alter the

 * the queue exceeds that value, the queue automatically removes its greatest element according to
 * its comparator (which might be the element that was just added). This is different from
 * conventional bounded queues, which either block or reject new elements when full.
 *
 * <p>This implementation is based on the <a
 * href="http://portal.acm.org/citation.cfm?id=6621">min-max heap</a> developed by Atkinson, et al.

     */
    protected volatile int state = 0;

    protected String name = "Transport" + id++;
    private volatile Thread thread;
    private volatile TransportException te;

    protected final Object inLock = new Object();
    protected final Object outLock = new Object();

    protected final Map<Long, Response> response_map = new ConcurrentHashMap<>(10);
    private final AtomicLong usageCount = new AtomicLong(1);

    private final Object domainsLock = new Object();

    private final Map<String, CacheEntry<DfsReferralDataInternal>> dcCache = new HashMap<>();
    private final Object dcLock = new Object();

    private CacheEntry<DfsReferralDataInternal> referrals = null;
    private final Object referralsLock = new Object();


    /**
     * @param tc
     * 
     */

    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_NONE = 0x0;
    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_II = 0x1;
    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_EXCLUSIVE = 0x8;
    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_BATCH = 0x9;
    /**
     * 
     */

        case SMB2_QUERY_INFO:
            c = "SMB2_QUERY_INFO";
            break;
        case SMB2_SET_INFO:
            c = "SMB2_SET_INFO";
            break;
        case SMB2_OPLOCK_BREAK:
            c = "SMB2_OPLOCK_BREAK";
            break;
        default:
            c = "UNKNOWN";
        }
        String str = this.status == 0 ? "0" : SmbException.getMessageByCode(this.status);

                        create2.setRequestedOplockLevel(Smb2CreateRequest.SMB2_OPLOCK_LEVEL_BATCH);

                        create2.chain(new Smb2CloseRequest(sess.getConfig(), Smb2Constants.UNSPECIFIED_FILEID));

                        synchronized ( lock ) {
                            lock.notify();
                        }
                        tree.send(create2);
                    }