Returns <code>true</code> if the selection has blocking locks.<p>

@return <code>true</code> if the selection has blocking locks
162954
public boolean isLockStateOk() {

        org.opencms.workplace.commons.CmsLock lockDialog = new org.opencms.workplace.commons.CmsLock(getJsp());
        lockDialog.setParamIncluderelated(CmsStringUtil.TRUE);
        lockDialog.setBlockingFilter(getBlockingFilter());
        if (!isDirectPublish()) {
            lockDialog.setParamResource("/");
        }
        if (!lockDialog.getBlockingLockedResources().isEmpty()) {
            // blocking locks found, so show them
            return false;
        }
        if (!isDirectPublish()) {
            // is publish project operation no resource iteration possible
            return true;
        }

        // flag to indicate that all resources are exclusive locked
        boolean locked = true;
        // flag to indicate that all resources are unlocked
        boolean unlocked = true;

        Iterator<String> i = getResourceList().iterator();
        while (i.hasNext()) {
            String resName = i.next();
            try {
                CmsLock lock = getCms().getLock(getCms().readResource(resName, CmsResourceFilter.ALL));
                if (!lock.isUnlocked()) {
                    unlocked = false;
                    if (locked
                        && !lock.isOwnedInProjectBy(
                            getCms().getRequestContext().getCurrentUser(),
                            getCms().getRequestContext().getCurrentProject())) {
                        // locks of another users or locked in another project are blocking
                        locked = false;
                    }
                }
            } catch (CmsException e) {
                // error reading a resource, should usually never happen
                if (LOG.isErrorEnabled()) {
                    LOG.error(e.getLocalizedMessage(), e);
                }
            }
        }
        return locked || unlocked;
    }
1114513
public @Nonnull SetType getBlockedThreads() {
        Set<ThreadLock> acquired = new HashSet<ThreadLock>();
        for (ThreadType thread: threads) {
            acquired.addAll(thread.getAcquiredLocks());
        }

        Set<ThreadType> blocked = new HashSet<ThreadType>();
        for (ThreadType thread: runtime.getThreads()) {
            if (acquired.contains(thread.getWaitingToLock())) {
                blocked.add(thread);
            }
        }

        return runtime.getThreadSet(blocked);
    }
967343
public boolean checkLocks( boolean exclusive,
                               int depth ) {
        if (checkParents(exclusive) && checkChildren(exclusive, depth)) {
            return true;
        }
        return false;
    }
273473
@Override
    public boolean isBlocked() {
        final Collection<ApplicationDependency> blockingConditions = new ArrayList<ApplicationDependency>(blockAppStartingFutures);
        for (ApplicationDependency blockingCondition : blockingConditions) {
            if (!blockingCondition.isDone()) {
                return true;
            }
        }
        return false;
    }
1323290
boolean detectDeadlock(Locker acquirer, Lock l, int mode) {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "detectDeadlock", new Object[] { acquirer, l,
                                                         modeStrs[mode] });
        }

        boolean result = false;

        //----------------------------------------------------------------
        // Iterate through the holders of the given lock and determine if
        // any of them are waiting on a lock held by the requestor. If
        // any of them are then a deadlock exists.
        //----------------------------------------------------------------

        Enumeration holders = l.getHolders();
        while (holders.hasMoreElements()) {
            if (lockerWaitingOn((Locker) holders.nextElement(), acquirer)) {
                result = true;
                break;
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "detectDeadlock:" + result);
        }
        return result;

    }
132770
protected boolean lockJobIfNeeded() {
    try {
      if (job.isExclusive()) {
        processEngineConfiguration.getCommandExecutor().execute(new LockExclusiveJobCmd(job));
      }

    } catch (Throwable lockException) {
      if (log.isDebugEnabled()) {
        log.debug("Could not lock exclusive job. Unlocking job so it can be acquired again. Catched exception: " + lockException.getMessage());
      }

      // Release the job again so it can be acquired later or by another node
      unacquireJob();
      
      return false;
    }
    
    return true;
  }
651680
public function isLocked()
    {
        if($this->getModel()->getState()->isUnique())
        {
            $entity = $this->getModel()->fetch();

            if($entity->isLockable() && $entity->isLocked()) {
                return true;
            }
        }

        return false;
    }
225800
private boolean isStreamBlockedUnexpectedly()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isStreamBlockedUnexpectedly");
            SibTr.exit(tc, "isStreamBlockedUnexpectedly", Boolean.valueOf(unexpectedBlock));
        }
        return unexpectedBlock;

    }
552623
public boolean isAllSelected()
    {
        boolean bAllSelected = true;
        for (int iFieldSeq = DBConstants.MAIN_FIELD; iFieldSeq <= this.getFieldCount() + DBConstants.MAIN_FIELD - 1; iFieldSeq++)
        {
            if(this.getField(iFieldSeq).isSelected() == false)
                bAllSelected = false;
        }
        return bAllSelected;
    }
643096
public boolean hasNext() {
		if(cachedNext != null) {
			return true;
		}
		while(cachedNext == null) {
			if(br != null) {
				// attempt to read the next line from this:
				try {
					cachedNext = br.readLine();
					if(cachedNext == null) {
						br = null;
						// next loop:
					} else {
						return true;
					}
				} catch (IOException e) {
					e.printStackTrace();
					br = null;
				}
			} else {
				// do we have more blocks to use?
				if(blockItr.hasNext()) {
					try {
						br = blockItr.next().readBlock();
					} catch (IOException e) {
						throw new RuntimeIOException();
					}
				} else {
					return false;
				}
			}
		}
		
		return false;
	}
824088
private boolean isLocked(String path) {

        // get lock for path
        CmsRepositoryLockInfo lock = m_session.getLock(path);
        if (lock == null) {
            return false;
        }

        // check if found lock fits to the lock token from request
        //        String currentToken = "<opaquelocktoken:" + generateLockToken(req, lock) + ">";
        //        if (currentToken.equals(parseLockTokenHeader(req))) {
        //            return false;
        //        }

        if (lock.getUsername().equals(m_username)) {
            return false;
        }

        return true;
    }
522412
public @CheckForNull ThreadType getBlockingThread() {
        if (state.waitingToLock == null && state.waitingOnLock == null) {
            return null;
        }

        for (ThreadType thread: runtime.getThreads()) {
            if (thread == this) continue;
            Set<ThreadLock> acquired = thread.getAcquiredLocks();
            if (acquired.isEmpty()) continue;
            if (acquired.contains(state.waitingToLock) || acquired.contains(state.waitingOnLock)) {
                return thread;
            }
        }

        return null;
    }
1080362
def is_locked(self):
        
        if not self.__locked__:
            return False
        elif self.get_parent():
            return self.get_parent().is_locked()

        return True
228924
private boolean isLocked(Class entityType, String entityKey, Integer lockType)
            throws LockingException {
        IEntityLock[] locks = retrieveLocks(entityType, entityKey, lockType);
        return locks.length > 0;
    }
383026
public boolean writeLocked (@Nonnull final BooleanSupplier aSupplier)
  {
    writeLock ().lock ();
    try
    {
      return aSupplier.getAsBoolean ();
    }
    finally
    {
      writeLock ().unlock ();
    }
  }
1368590
public boolean lock(T jedis){
        UUID lockId = UUID.randomUUID();
        final String setResponse = jedis.set(redisSchema.lockKey(), lockId.toString(), "NX", "PX", lockTimeout);
        boolean lockAcquired = !isNullOrEmpty(setResponse) && setResponse.equals("OK");
        if(lockAcquired){
            // save the random value used to lock so that we can successfully unlock later
            lockValue = lockId;
        }
        return lockAcquired;
    }
632308
public boolean lockerWaitingOn(Locker locker, Locker target)
    {
        //-------------------------------------------------------------
        // Locker can be waiting on at most one lock. If that lock
        // is held by target or if any of the holders of that lock
        // is waiting on the target then locker is waiting on target.
        //-------------------------------------------------------------

        Lock waitingOn = (Lock) waitTable.get(locker);

        if (waitingOn == null) {
            return false;
        }

        Enumeration holders = waitingOn.getHolders();
        while (holders.hasMoreElements()) {
            Locker next = (Locker) holders.nextElement();
            if (next == target) {
                return true;
            }
            if (lockerWaitingOn(next, target)) {
                return true;
            }
        }
        return false;
    }