Check from another ConcurrentGroupServerUpdatePolicy whose plans are meant to
execute once this policy's plans are successfully completed.

@return <code>true</code> if the successor can proceed
167092
private boolean canSuccessorProceed() {

        if (predecessor != null && !predecessor.canSuccessorProceed()) {
            return false;
        }

        synchronized (this) {
            while (responseCount < groups.size()) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return false;
                }
            }
            return !failed;
        }
    }
1203678
private void updateEligibility()
    {
        checkState(Thread.holdsLock(root), "Must hold lock to update eligibility");
        synchronized (root) {
            if (!parent.isPresent()) {
                return;
            }
            if (isEligibleToStartNext()) {
                parent.get().addOrUpdateSubGroup(this);
            }
            else {
                parent.get().eligibleSubGroups.remove(this);
                lastStartMillis = 0;
            }
            parent.get().updateEligibility();
        }
    }
826736
public final boolean tryLockForUpgrade(L locker, long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return tryLockForUpgrade_(locker, timeout, unit) != Result.FAILED;
    }
24126
@Override
    public boolean isCorruptOrIndoubt()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isCorruptOrIndoubt");

        boolean isCorruptOrIndoubt = _targetDestinationHandler.isCorruptOrIndoubt();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isCorruptOrIndoubt", Boolean.valueOf(isCorruptOrIndoubt));

        return isCorruptOrIndoubt;
    }
705170
public boolean isRevisitNotModified() {
		Map<String, Object> warcHeaders = getWarcHeaders().getHeaderFields();
		String warcProfile = (String)warcHeaders.get("WARC-Profile");
		return PROFILE_REVISIT_SERVER_NOT_MODIFIED.equals(warcProfile);
	}
684895
public boolean commit(KafkaMessage msg) {
        KafkaConsumer<String, byte[]> consumer = _getConsumer(msg.topic());
        synchronized (consumer) {
            Set<String> subscription = consumer.subscription();
            if (subscription == null || !subscription.contains(msg.topic())) {
                // this consumer has not subscribed to the topic
                return false;
            } else {
                try {
                    Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
                    offsets.put(new TopicPartition(msg.topic(), msg.partition()),
                            new OffsetAndMetadata(msg.offset() + 1));
                    consumer.commitSync(offsets);
                } catch (WakeupException e) {
                } catch (Exception e) {
                    throw new KafkaException(e);
                }
                return true;
            }
        }
    }
700011
boolean isKeepaliveAllowed(long connectionStartTime)
  {
    if (! _lifecycle.isActive()) {
      return false;
    }
    else if (connectionStartTime + _keepaliveTimeMax < CurrentTime.currentTime()) {
      return false;
    }
    else if (_keepaliveMax <= _keepaliveAllocateCount.get()) {
      return false;
    }
    /*
    else if (_connThreadPool.isThreadMax()
             && _connThreadPool.isIdleLow()
             && ! isKeepaliveAsyncEnabled()) {
      return false;
    }
    */
    else {
      return true;
    }
  }
1069583
private boolean jobHasScheduledStatus() {

		final Iterator<ExecutionVertex> it = new ExecutionGraphIterator(this, true);

		while (it.hasNext()) {

			final ExecutionState s = it.next().getExecutionState();
			if (s != ExecutionState.CREATED && s != ExecutionState.SCHEDULED && s != ExecutionState.READY) {
				return false;
			}
		}

		return true;
	}
1324366
private boolean okayToSendServerStarted() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "okayToSendServerStarted", this);

        synchronized (lockObject) {
            if (!_sentServerStarted) {
                if ((_state == STATE_STARTED) && _mainImpl.isServerStarted()) {
                    _sentServerStarted = true;
                }
            }
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "okayToSendServerStarted", new Boolean(_sentServerStarted));
        return _sentServerStarted;
    }
877246
@Override
	public boolean next() {
		if (currentScan != null) {
			if (currentScan == s1)
				hasMore1 = s1.next();
			else if (currentScan == s2)
				hasMore2 = s2.next();
		}

		if (!hasMore1 && !hasMore2)
			return false;
		else if (hasMore1 && hasMore2) {
			// update currentScan
			currentScan = comp.compare(s1, s2) < 0 ? s1 : s2;
		} else if (hasMore1)
			currentScan = s1;
		else if (hasMore2)
			currentScan = s2;
		return true;
	}
730953
def is_ready_to_next_step(self):
        
        return (bool(self.rbAggLayerFromCanvas.isChecked()
                     or self.rbAggLayerFromBrowser.isChecked()
                     or self.rbAggLayerNoAggregation.isChecked()))
1362831
public boolean commmit(KafkaMessage msg, String groupId) {
        KafkaMsgConsumer kafkaConsumer = cacheConsumers.get(groupId);
        return kafkaConsumer != null ? kafkaConsumer.commit(msg) : false;
    }
308762
@Override
    public boolean isReconciled()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "isReconciled");
            SibTr.exit(tc, "isReconciled", Boolean.valueOf(_reconciled));
        }

        return _reconciled;
    }
285086
private static boolean canBeContinued(final String fileName, final List<Policy> policies) {
		boolean result = true;
		for (Policy policy : policies) {
			result &= policy.continueExistingFile(fileName);
		}
		return result;
	}
395146
public boolean hasRejections() {
        boolean rejections = policy != null && "Reject".equals(policy.getActionType());

        Iterator<PolicyCheckResourceNode> it = children.iterator();
        while (it.hasNext() && !rejections) {
            rejections = it.next().hasRejections();
        }

        return rejections;
    }
696885
private boolean checkPolicy(int executionCount) {
		if (mechanism.equalsIgnoreCase("fixedretry")) {
			if (this.retryCount == 0) {
				return false;
			} else if (executionCount < this.retryCount) {
				try {
					Thread.sleep((long) this.retryInterval);
					LOG.debug("The retryInterval " + this.retryInterval);
					return true;
				} catch (Exception e) {
					LOG.error(e.getMessage());
				}
			}
			return false;
		}

		// functionality for incremental retry policy
		if (mechanism.equalsIgnoreCase("incrementalretry")) {
			if (executionCount < this.retryCount) {
				try {
					Thread.sleep((long) this.initialInterval + (this.increment * executionCount));
					return true;
				} catch (Exception e) {
					LOG.error(e.getMessage());
				}
			}
			return false;
		}
		// functionality for exponential retry
		if (mechanism.equalsIgnoreCase("exponentialretry")) {
			if (executionCount < this.retryCount) {
				try {
					int delta = (int) ((Math.pow(2.0, executionCount) - 1.0)
							* (this.deltaBackoff * NUM_0_8) + (Math.random()
							* (this.deltaBackoff * NUM_1_2)
							- (this.deltaBackoff * NUM_0_8) + 1));
					int interval = (int) Math.min((this.minBackoff + delta), this.maxBackoff);
					Thread.sleep(interval);
				} catch (Exception e) {
					LOG.error(e.getMessage());
				}
				return true;
			}
			return false;
		}
		return true;
	}
1160900
private boolean consideringHierarchy(Publish p) {
		boolean sent = false;
		for (Entry<Class<?>, List<SubscriberParent>> e : p.mapping.entrySet()) {
			if (e.getKey().isAssignableFrom(p.message.getClass())) {
				for (SubscriberParent parent : e.getValue()) {
					if (!predicateApplies(parent.getSubscriber(), p.message)) {
						continue;
					}
					parent.getSubscriber().receiveO(p.message);
					sent = true;
				}
			}
		}
		return sent;
	}