Performs a single flow through a node.

@return {@code true} if the flow state differs from the previous state.
427156
protected boolean flow(DiGraphNode<N, Branch> node) {
    FlowState<L> state = node.getAnnotation();
    if (isForward()) {
      L outBefore = state.out;
      state.out = flowThrough(node.getValue(), state.in);
      return !outBefore.equals(state.out);
    } else {
      L inBefore = state.in;
      state.in = flowThrough(node.getValue(), state.out);
      return !inBefore.equals(state.in);
    }
  }
532784
private static boolean nodeHasCall(Node node) {
    return NodeUtil.has(node, new Predicate<Node>() {
      @Override
      public boolean apply(Node input) {
        return input.isCall() || input.isNew() || input.isTaggedTemplateLit();
      }},
      NOT_FUNCTION_PREDICATE);
  }
1345826
public Stop<Flow<T>> getOrCreateStop()
   {
      List<Node> nodeList = childNode.get("stop");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new StopImpl<Flow<T>>(this, "stop", childNode, nodeList.get(0));
      }
      return createStop();
   }
1352044
private static boolean isRunningInWAS() {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(TRACE, "isRunningInWAS");
        }

        if (inWAS == null) {
            inWAS = Boolean.TRUE;
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(TRACE, "isRunningInWAS", inWAS);
        }
        return inWAS.booleanValue();
    }
1075855
public boolean lastChild() {
        if (mNode == null || mNode.getChildCount() < 1) {
            return false;
        }
        for (int i = mNode.getChildCount() - 1; i >= 0; --i) {
            AccessibilityNodeInfoCompat newNode = mNode.getChild(i);
            if (newNode == null) {
                return false;
            }
            if (AccessibilityNodeInfoUtils.isVisibleOrLegacy(newNode)) {
                reset(newNode);
                return true;
            }
            newNode.recycle();
        }
        return false;
    }
225380
NodeState<T> follow(StartElement element) {
        assert (element != null);
        for (NodeTransition<T> transition : transitions) {
            if (transition.getTest().matches(element)) {
                return transition.getTarget();
            }
        }
        return emptyState();
    }
246599
public boolean isPreviousThan(Node node) {
        if (getEndLine() < node.getBeginLine()) {
            return true;
        } else if ((getEndLine() == node.getBeginLine()) && (getEndColumn() <= node.getBeginColumn())) {
            return true;
        }
        return false;
    }
379661
private final boolean checkUnderflowWithLeft(final int slot) {
		final Node<K, V> nodeRight = tree.getNode(childs[slot]);
		if (nodeRight.isUnderFlow()) {
			final Node<K, V> nodeLeft = tree.getNode(childs[slot - 1]);
			if (nodeLeft.canMerge(nodeRight)) {
				nodeLeft.merge(this, slot - 1, nodeRight);
			} else {
				nodeRight.shiftLR(this, slot - 1, nodeLeft);
			}
			//
			// Update Changed Nodes
			tree.putNode(this);
			tree.putNode(nodeLeft);
			tree.putNode(nodeRight);
			return true;
		}
		return false;
	}
174770
private boolean fastAllPathsReturnCheck(ControlFlowGraph<Node> cfg) {
    for (DiGraphEdge<Node, Branch> s : cfg.getImplicitReturn().getInEdges()) {
      Node n = s.getSource().getValue();
      // NOTE(dimvar): it is possible to change ControlFlowAnalysis.java, so
      // that the calls that always throw are treated in the same way as THROW
      // in the CFG. Then, we would not need to use the coding convention here.
      if (!n.isReturn() && !convention.isFunctionCallThatAlwaysThrows(n)) {
        return false;
      }
    }
    return true;
  }
957011
public boolean containsSubflowState(final Flow flow, final String stateId) {
        if (containsFlowState(flow, stateId)) {
            return getState(flow, stateId, SubflowState.class) != null;
        }
        return false;
    }
473860
public synchronized boolean tryDelegateSlop(Node node) {
        if(asyncCallbackShouldSendhint) {
            return false;
        } else {
            slopDestinations.put(node, true);
            return true;
        }
    }
603534
public boolean isFlowActive() {
        Object val = this.getArgument("active");
        if (val instanceof Integer) {
            return ((Integer)val).intValue() == 1;
        }
        else {
            throw new IllegalStateException("ChannelEvent does not contain the 'active' argument");
        }
    }
889042
public boolean process() {
		if( graph.nodes.size() < 2 )
			return false;
		stopRequested = false;

		declareModelFitting();

		for (int i = 0; i < graph.nodes.size(); i++) {
			if( verbose != null )
				verbose.print("Matching node "+i+" -> ");
			associate.setSource(graph.nodes.get(i).descriptions);
			for (int j = i+1; j < graph.nodes.size(); j++) {
				associate.setDestination(graph.nodes.get(j).descriptions);
				associate.associate();
				if( associate.getMatches().size < MIN_FEATURE_ASSOCIATED )
					continue;

				boolean connected = connectViews(graph.nodes.get(i),graph.nodes.get(j),associate.getMatches());
				if( verbose != null ) {
					if( connected )
						verbose.print("+");
					else
						verbose.print("-");
				}

				if( stopRequested )
					return false;
			}
			if( verbose != null ) {
				verbose.println();
			}
		}
		return graph.edges.size() >= 1;
	}
371528
public Next<Flow<T>> getOrCreateNext()
   {
      List<Node> nodeList = childNode.get("next");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new NextImpl<Flow<T>>(this, "next", childNode, nodeList.get(0));
      }
      return createNext();
   }
923071
@Override
    public Flow getFlow()
    {
        return new Flow()
        {
            @Override
            public boolean isHandled()
            {
                return false;
            }

            @Override
            public boolean is(Flow type)
            {
                return false;
            }
        };
    }
204248
public boolean removeNode(RiakNode node)
    {
        stateCheck(State.CREATED, State.RUNNING, State.QUEUING);
        boolean removed = false;
        try
        {
            nodeListLock.writeLock().lock();
            removed = nodeList.remove(node);
            for (NodeStateListener listener : stateListeners)
            {
                node.removeStateListener(listener);
            }
        }
        finally
        {
            nodeListLock.writeLock().unlock();
        }
        nodeManager.removeNode(node);
        return removed;
    }
788087
protected boolean handlePausedFlow(Execution execution) throws InterruptedException {
        String branchId = execution.getSystemContext().getBranchId();
        PauseReason reason = findPauseReason(execution.getExecutionId(), branchId);
        if (reason != null) { // need to pause the execution
            pauseFlow(reason, execution);
            return true;
        }
        return false;
    }