Is the stream marked as blocked.

@return true if the stream is blocked.
545318
private boolean isStreamBlocked()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isStreamBlocked");
            SibTr.exit(tc, "isStreamBlocked", new Object[] { Boolean.valueOf(isStreamBlocked),
                                                            Long.valueOf(linkBlockingTick) });
        }
        return this.isStreamBlocked;

    }
913492
boolean openStream() throws InterruptedException, IOException {
    logger.info("stream START");
    final boolean isOpen;
    final Set<BsonValue> idsToWatch = nsConfig.getSynchronizedDocumentIds();

    if (!networkMonitor.isConnected()) {
      logger.info("stream END - Network disconnected");
      return false;
    }

    if (idsToWatch.isEmpty()) {
      logger.info("stream END - No synchronized documents");
      return false;
    }

    nsLock.writeLock().lockInterruptibly();
    try {
      if (!authMonitor.isLoggedIn()) {
        logger.info("stream END - Logged out");
        return false;
      }

      final Document args = new Document();
      args.put("database", namespace.getDatabaseName());
      args.put("collection", namespace.getCollectionName());
      args.put("ids", idsToWatch);

      currentStream =
        service.streamFunction(
            "watch",
            Collections.singletonList(args),
            ResultDecoders.changeEventDecoder(BSON_DOCUMENT_CODEC));

      if (currentStream != null && currentStream.isOpen()) {
        this.nsConfig.setStale(true);
        isOpen = true;
      } else {
        isOpen = false;
      }
    } finally {
      nsLock.writeLock().unlock();
    }
    return isOpen;
  }
651680
public function isLocked()
    {
        if($this->getModel()->getState()->isUnique())
        {
            $entity = $this->getModel()->fetch();

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

        return false;
    }
705734
private static boolean isSharedFileLockTable() {
        if (!propertyChecked) {
            synchronized (FileChannelImpl.class) {
                if (!propertyChecked) {
                    /*
                    String value = AccessController.doPrivileged(
                        new GetPropertyAction(
                            "sun.nio.ch.disableSystemWideOverlappingFileLockCheck"));
                    */
                    String value =
                        System.getProperty("sun.nio.ch.disableSystemWideOverlappingFileLockCheck");
                    isSharedFileLockTable = ((value == null) || value.equals("false"));
                    propertyChecked = true;
                }
            }
        }
        return isSharedFileLockTable;
    }
35833
private boolean blocked(Task task) throws InterruptedException
   {
      lock.lockInterruptibly();

      try
      {
         TaskAttribute executing =
               enabled.size() > 0
                     ? enabled.get(enabled.size() - 1).getCommand().getTaskAttribute()
                     : null;
         {
            switch (task.getCommand().getTaskAttribute())
            {
               case SIMPLE :
                  if (executing == null || executing == TaskAttribute.SIMPLE)
                     return false;
                  else
                     return true;
               case HEAD_OF_QUEUE :
                  return false;
               case ORDERED :
                  if (executing == null)
                     return false;
                  else
                     return true;
               default :
                  throw new RuntimeException("Unsupported task tag: "
                        + task.getCommand().getTaskAttribute().name());
            }
         }
      }
      finally
      {
         lock.unlock();
      }
   }
1052433
public boolean isLocked() {

		// always return false when lock is disabled

		if (disabled.get()) {
			return false;
		}

		// check if locked by current process

		if (locked.get()) {
			return true;
		}

		// check if locked by other process

		if (!lock.exists()) {
			return false;
		}

		long now = System.currentTimeMillis();
		long tsp = read();

		LOG.trace("Lock timestamp {} now {} for {}", tsp, now, webcam);

		if (tsp > now - INTERVAL * 2) {
			return true;
		}

		return false;
	}
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;
	}
560291
private boolean isTileBlocked(Pathfindable mover, int tx, int ty)
    {
        final Tile tile = map.getTile(tx, ty);
        if (tile != null)
        {
            final TilePath tilePath = tile.getFeature(TilePath.class);
            return mover.isBlocking(tilePath.getCategory());
        }
        return false;
    }
1179442
public boolean wasSkipped() {
        return getSteps().stream().filter(s -> s.getEndState() != StepEndState.SKIPPED).count() == 0;
    }
808090
public final boolean isOutCommitted()
  {
    OutHttpApp stream = out();
    
    if (stream.isCommitted()) {
      return true;
    }

    // server/05a7
    if (_contentLengthOut > 0 && _contentLengthOut <= stream.contentLength()) {
      return true;
    }

    return false;
  }
201875
private boolean isProxied(HttpServletRequest httpServletRequest) {
        if (Proxy.isProxyClass(httpServletRequest.getClass())) {
            InvocationHandler handler = Proxy.getInvocationHandler(httpServletRequest);
            return handler instanceof ServletRequestInvocationHandler;
        }
        return false;
    }
826694
public function canAddblock()
    {
        if (!$this->actor) {
            return false;
        }

        if (!$this->getItem()) {
            return false;
        }

        if ($this->getItem()->isAdministrable() && !$this->canAdminister()) {
            return false;
        }

        return $this->actor->authorize('blocker', array('viewer' => $this->getItem()));
    }
255143
private boolean registerStream(IClientStream stream) {
        if (streams.putIfAbsent(stream.getStreamId().doubleValue(), stream) == null) {
            usedStreams.incrementAndGet();
            return true;
        }
        log.error("Unable to register stream {}, stream with id {} was already added", stream, stream.getStreamId());
        return false;
    }
649185
public boolean isIdle() {
        long lastPingTime = lastPingSentOn.get();
        long lastPongTime = lastPongReceivedOn.get();
        boolean idle = (lastPongTime > 0 && (lastPingTime - lastPongTime > maxInactivity));
        if (log.isTraceEnabled()) {
            log.trace("Connection {} {} idle", getSessionId(), (idle ? "is" : "is not"));
        }
        return idle;
    }
663855
public boolean isSendAllowed()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "isSendAllowed");
    
    boolean sendAllowed;
    if(_sendAllowedOnTargetForeignBus.equals(Boolean.FALSE))
      sendAllowed =  false;
    else
      sendAllowed = _foreignDestinationDefault.isSendAllowed();     
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "isSendAllowed", sendAllowed);
    
    return sendAllowed;
  }
919180
private boolean isBlockingLocked() {

        boolean result = true;
        CmsLockFilter blockingFilter = CmsLockFilter.FILTER_ALL;
        blockingFilter = blockingFilter.filterNotLockableByUser(getCms().getRequestContext().getCurrentUser());
        try {
            List<String> blocking = getCms().getLockedResources(getParamResource(), blockingFilter);
            result = blocking.size() > 0;
        } catch (CmsException e) {
            if (LOG.isDebugEnabled()) {
                LOG.debug(e.getLocalizedMessage(), e);
            }
        }
        return result;
    }
301821
private synchronized final boolean isStateLocked()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isStateLocked");
            SibTr.exit(this, tc, "isStateLocked", _itemLinkState);
        }
        if (_itemLinkState == ItemLinkState.STATE_LOCKED)
        {
            return true;
        }
        else
        {
            return false;
        }
    }