/** @see LockManager#getTimeoutInfo */
  @Override
  TimeoutInfo getTimeoutInfo(
      boolean isLockNotTxnTimeout,
      Locker locker,
      long lsn,
      LockType type,
      LockGrantType grantType,
      Lock useLock,
      long timeout,
      long start,
      long now,
      DatabaseImpl database)
      throws DatabaseException {

    if (locker.lockingRequired()) {
      return superiorLockManager.getTimeoutInfo(
          isLockNotTxnTimeout,
          locker,
          lsn,
          type,
          grantType,
          useLock,
          timeout,
          start,
          now,
          database);
    }
    return null;
  }
  /** @see LockManager#demote */
  @Override
  void demote(long lsn, Locker locker) throws DatabaseException {

    if (locker.lockingRequired()) {
      superiorLockManager.demote(lsn, locker);
    } else {
      return;
    }
  }
  /** @see LockManager#stealLock */
  @Override
  public LockAttemptResult stealLock(Long lsn, Locker locker, LockType lockType)
      throws DatabaseException {

    if (locker.lockingRequired()) {
      return superiorLockManager.stealLock(lsn, locker, lockType);
    }
    return null;
  }
  /** @see LockManager#validateOwnership */
  @Override
  boolean validateOwnership(
      Long lsn, Locker locker, LockType type, boolean flushFromWaiters, MemoryBudget mb)
      throws DatabaseException {

    if (locker.lockingRequired()) {
      return superiorLockManager.validateOwnership(lsn, locker, type, flushFromWaiters, mb);
    }
    return true;
  }
  /** @see LockManager#attemptLock */
  @Override
  LockAttemptResult attemptLock(
      Long lsn,
      Locker locker,
      LockType type,
      boolean nonBlockingRequest,
      boolean jumpAheadOfWaiters)
      throws DatabaseException {

    if (locker.lockingRequired()) {
      return superiorLockManager.attemptLock(
          lsn, locker, type, nonBlockingRequest, jumpAheadOfWaiters);
    }
    return new LockAttemptResult(null, LockGrantType.NEW, true);
  }
  /** @see LockManager#releaseAndFindNotifyTargets */
  @Override
  Set<Locker> releaseAndFindNotifyTargets(long lsn, Locker locker) throws DatabaseException {

    /*
     * Unconditionally release the lock.  This does not detract from the
     * performance benefit of disabled locking, since this method is only
     * called if a lock was previously acquired, i.e., it is held by a
     * Locker.
     *
     * The comment below is now obsolete because handle locks are no longer
     * transferred.
     *   If the release of the lock were conditional, a lock transferred
     *   between Lockers (as we do with Database handle locks) would never
     *   be released, since the destination Locker's lockingRequired
     *   property is not set to true.  In general, it is safer to
     *   unconditionally release locks than to rely on the lockingRequired
     *   property. [#17985]
     */
    return superiorLockManager.releaseAndFindNotifyTargets(lsn, locker);
  }
  /** @see LockManager#lookupLock */
  @Override
  Lock lookupLock(Long lsn) throws DatabaseException {

    Lock ret = superiorLockManager.lookupLock(lsn);
    return ret;
  }
 @Override
 public boolean isLockUncontended(Long lsn) {
   return superiorLockManager.isLockUncontended(lsn);
 }
 @Override
 public LockType getOwnedLockType(Long lsn, Locker locker) {
   return superiorLockManager.getOwnedLockType(lsn, locker);
 }
 @Override
 public Set<LockInfo> getOwners(Long lsn) {
   return superiorLockManager.getOwners(lsn);
 }
  /** @see LockManager#dumpLockTable */
  @Override
  void dumpLockTable(StatGroup stats, boolean clear) throws DatabaseException {

    superiorLockManager.dumpLockTable(stats, clear);
  }
  /** @see LockManager#getWriterOwnerLocker */
  @Override
  Locker getWriteOwnerLocker(Long lsn) throws DatabaseException {

    return superiorLockManager.getWriteOwnerLocker(lsn);
  }
  /** @see LockManager#nOwners */
  @Override
  int nOwners(Long lsn) throws DatabaseException {

    return superiorLockManager.nOwners(lsn);
  }
  /** @see LockManager#isWaiter */
  @Override
  boolean isWaiter(Long lsn, Locker locker) throws DatabaseException {

    return superiorLockManager.isWaiter(lsn, locker);
  }
  /** @see LockManager#isOwner */
  @Override
  boolean isOwner(Long lsn, Locker locker, LockType type) throws DatabaseException {

    return superiorLockManager.isOwner(lsn, locker, type);
  }
  /** @see LockManager#isLocked */
  @Override
  boolean isLocked(Long lsn) throws DatabaseException {

    return superiorLockManager.isLocked(lsn);
  }