Flag that the processor has started execution.

@param processorGraphNode the node that has started.
509627
private void started(final ProcessorGraphNode processorGraphNode) {
        this.processorLock.lock();
        try {
            this.runningProcessors.put(processorGraphNode.getProcessor(), null);
        } finally {
            this.processorLock.unlock();
        }
    }
148824
public void setProcessorOptions(String processorOptions)
	{
		StringTokenizer tok = new StringTokenizer(processorOptions, ",");
		while (tok.hasMoreTokens())
			_processorOptions.add(tok.nextToken());
	}
672000
private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }
816773
private void startupProcessor() {
        Processor processor = processorRef.get();
        if (processor == null) {
            processor = new Processor();
            if (processorRef.compareAndSet(null, processor)) {
                executor.execute(new NamePreservingRunnable(processor,
                        threadName));
            }
        }

        // Just stop the select() and start it again, so that the processor
        // can be activated immediately. 
        wakeup();
    }
1347759
public void onNodeFinished(final IExecutionNode node) {

        final Description description = descriptionMap.get(Long.valueOf(node.getId()));
        notifyTestFinished(description);

    }
454611
function(node) {
			this.currentNode = node;// Updates the code path.
			// And emits onCodePathStart/onCodePathSegmentStart events.
			processCodePathToExit(this, node);

			// Emits node events.
			this.original.leaveNode(node);

			// Emits the last onCodePathStart/onCodePathSegmentStart events.
			postprocess(this, node);

			this.currentNode = null;
		}
253121
@Override
    public void onNodeStarted(ZWaveNode node) {
        // save the newly started node
        logger.debug("Saving information for node {}", node.getNodeId());
        store.saveNode(node);

        // when a node moves to the "started" state, alert listeners that it's ready to be added
        onZWaveNodeAdded(node);
    }
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;
        }
    }
1006064
function startReadyProcesses()
    {
        // Start as many processes as we can!
        //writeToLog("INFO", "***** maxNumberOfRunningProcesses = " + maxNumberOfRunningProcesses + "; numberOfRunningProcesses = " + numberOfRunningProcesses);
        var numVertices = graph.vertexCount();
        var vertexIds = graph.getVertexIds();

        for(var i = 0; i < numVertices; i++)
        {
            if(graph.getVertex(vertexIds[i]).state == "READY")
            {
                if(maxNumberOfRunningProcesses > 0 && numberOfRunningProcesses < maxNumberOfRunningProcesses)
                {
                    numberOfRunningProcesses++;
                    graph.getVertex(vertexIds[i]).setState("IN_PROGRESS");
                }
                else if(maxNumberOfRunningProcesses <= 0)
                {
                    numberOfRunningProcesses++;
                    graph.getVertex(vertexIds[i]).setState("IN_PROGRESS");
                }
            }
        }
    }
753896
private void processIgnoredLeadingTokens(ParseTreeNode node, int position, int line, MemoEntry progress)
	    throws TreeException, ParserException {
	if (ignoredLeading) {
	    processIgnoredTokens(node, position, line, progress);
	}
    }
755916
public boolean isFinished(final ProcessorGraphNode processorGraphNode) {
        this.processorLock.lock();
        try {
            return this.executedProcessors.containsKey(processorGraphNode.getProcessor());
        } finally {
            this.processorLock.unlock();
        }
    }
457930
public boolean allAreFinished(final Set<ProcessorGraphNode<?, ?>> processorNodes) {
        this.processorLock.lock();
        try {
            for (ProcessorGraphNode<?, ?> node: processorNodes) {
                if (!isFinished(node)) {
                    return false;
                }
            }
            return true;
        } finally {
            this.processorLock.unlock();
        }

    }
848833
@Override
	protected void onCreate() {
		logger.debug("PE ID {}", getId());		
				if (this.processor != null) {
			this.processor = this.processor.newProcessor(this.processor);
			this.processor.onCreate(Integer.parseInt(getId()));
		}
	}
218049
public void setProcessors(java.util.Collection<Processor> processors) {
        if (processors == null) {
            this.processors = null;
            return;
        }

        this.processors = new java.util.ArrayList<Processor>(processors);
    }
276146
public final void serverStarted() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "serverStarted", this);

        if (okayToSendServerStarted()) {

            Iterator<ComponentList> vIter = jmeComponents.iterator();
            while (vIter.hasNext()) {
                vIter.next().getRef().serverStarted();
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "serverStarted");
    }
1092918
private void runCypher(final String line, final Writable writable) throws FrameworkException, IOException {

		final App app = StructrApp.getInstance(actionContext.getSecurityContext());

		try (final Tx tx = app.tx()) {

			final long t0                  = System.currentTimeMillis();
			final List<GraphObject> result = Iterables.toList(app.query(line, Collections.emptyMap()));
			final long t1                  = System.currentTimeMillis();
			final int size                 = result.size();

			writable.print("Query returned ", size, " objects in ", (t1-t0), " ms.");
			writable.println();
			writable.println();

			if (size <= 10) {

				writable.print(Functions.get("to_json").apply(actionContext, null, new Object[] { result } ));

			} else {

				writable.print("Too many results (> 10), please use LIMIT to reduce the result count of your Cypher query.");
			}

			writable.println();

			tx.success();
		}

	}
725895
protected void processNodeCreated(String path) {
    if (path.equals(masterZnode)) {
      LOG.info(masterZnode + " created and try to become active master");
      handleMasterNodeChange();
    }
  }