Transition to the next workflow state (hence next state of the statemachine based on the command paylaod).

@param ProceedWorkflowCommand $move_node_command
966279
public function moveNode(MoveAggregateRootNodeCommand $move_node_command)
    {
        $this->guardCommandPreConditions($move_node_command);

        $node_moved_event = $this->processCommand(
            $move_node_command,
            [ 'data' => [ 'parent_node_id' => $move_node_command->getParentNodeId() ] ]
        );

        if (!$node_moved_event instanceof AggregateRootNodeMovedEvent) {
            throw new UnsupportedEventTypeError(
                sprintf(
                    'Corrupt event type detected. Events that reflect nodes being moved must descend from %s.',
                    AggregateRootNodeMovedEvent::CLASS
                )
            );
        }

        $this->applyEvent($node_moved_event);
    }
715291
public function execute($command, callable $next)
    {
        $migration = $command->getMigration();
        $direction = $command->getOptions()->getDirection()->isUp() ? 'up' : 'down';

        $migration->$direction();
    }
1164911
private void forwardCommandRemotely(RemoteTransaction remoteTx) {
      Set<Object> affectedKeys = remoteTx.getAffectedKeys();
      if (trace)
         log.tracef("Invoking forward of TxCompletionNotification for transaction %s. Affected keys: %s", gtx,
               toStr(affectedKeys));
      stateTransferManager.forwardCommandIfNeeded(this, affectedKeys, remoteTx.getGlobalTransaction().getAddress());
   }
37781
function _processActionQueue()
	{	
		if( _actionQueue.length > 0 ) {
			var stateEvent = _actionQueue.shift();
			
			if(!_currentState.getTarget(stateEvent.action)) {
				_processActionQueue();
			} 
			else {
			}	FSM.action( stateEvent.action, stateEvent.data );

			return false;
		}

		FSM.log('State transition Completed! Current State :: ' + _currentState.name );
		stateChanged.dispatch(_currentState);
	}
398592
public function beforeNodeMove(NodeInterface $movedNode, NodeInterface $referenceNode, $moveOperation)
    {
        if (!$this->eventEmittingService->isEnabled()) {
            return;
        }

        $this->currentlyMoving += 1;

        /* @var $nodeEvent NodeEvent */
        $nodeEvent = $this->eventEmittingService->emit(self::NODE_MOVE, [
            'referenceNode' => $referenceNode->getContextPath(),
            'moveOperation' => $moveOperation
        ], NodeEvent::class);
        $nodeEvent->setNode($movedNode);
        $this->eventEmittingService->pushContext();
    }
1207108
private void updateNeigbor(Collection<Tile> resolved,
                               Collection<Tile> toResolve,
                               Tile tile,
                               Tile neighbor,
                               int ox,
                               int oy)
    {
        final String group = mapGroup.getGroup(tile);
        final String neighborGroup = mapGroup.getGroup(neighbor);

        final Transition transitionA = getTransition(tile, neighborGroup);
        final Transition transitionB = getTransition(neighbor, group);

        if (transitionA != null && transitionB != null)
        {
            final TransitionType transitionTypeA = transitionA.getType();
            final TransitionType transitionTypeB = transitionB.getType();

            final TransitionType newType = getTransition(transitionTypeA, transitionTypeB, ox, oy);
            if (newType != null)
            {
                final Transition newTransition = new Transition(newType, transitionA.getOut(), transitionB.getIn());
                updateTransition(resolved, toResolve, tile, neighbor, neighborGroup, newTransition);
            }
        }
    }
704067
public function execute($command, callable $next)
    {
        $migration = $command->getMigration();
        if ($migration instanceof OptionsAwareInterface) {
            $migration->setOptions($command->getOptions());
        }

        $next($command);
    }
532090
public function moveNext()
    {
        $this->peek = 0;
        $this->token = $this->next;
        $this->next = isset($this->tokens[++$this->i]) ? $this->tokens[$this->i] : null;

        return null !== $this->next;
    }
283373
public function applyTransition(Workflow $workflow, AbstractSubject $subject, string $transitionName): bool
    {
        try {
            $workflow->apply($subject, $transitionName);
        } catch (TransitionException $exception) {
            return false;
        }

        return true;
    }
1298858
protected final synchronized void transitionState(OperationState newState) {
    getLogger().debug("Transitioned state from %s to %s", state, newState);
    state = newState;
    // Discard our buffer when we no longer need it.
    if(state != OperationState.WRITE_QUEUED
        && state != OperationState.WRITING) {
      cmd = null;
    }
    if (state == OperationState.COMPLETE) {
      callback.complete();
    }
  }
171410
public function updateMovedDocument(MoveEvent $event)
    {
        $document = $event->getDocument();
        if (!$document instanceof ResourceSegmentBehavior) {
            return;
        }

        $webspaceKey = $this->documentInspector->getWebspace($event->getDocument());
        if (!$webspaceKey) {
            return;
        }

        $resourceLocatorStrategy = $this->resourceLocatorStrategyPool->getStrategyByWebspaceKey($webspaceKey);
        if (ResourceLocatorStrategyInterface::INPUT_TYPE_LEAF !== $resourceLocatorStrategy->getInputType()) {
            return;
        }

        $this->updateRoute($document, true);
    }
993636
function MoveNext()
	{
		if (!$this->EOF) {
			$this->_currentRow++;
			if ($this->_numOfRows < 0 || $this->_numOfRows > $this->_currentRow) {
				$this->fields = @pg_fetch_array($this->_queryID,$this->_currentRow,$this->fetchMode);

				if (is_array($this->fields)) {
					if ($this->fields && isset($this->_blobArr)) $this->_fixblobs();
					return true;
				}
			}
			$this->fields = false;
			$this->EOF = true;
		}
		return false;
	}
50302
@Override
    public void setState(TransferState state) {
        super.setState(state);

        switch (state) {
        case Waiting:
            fireProgressEvent(ProgressEventType.TRANSFER_PREPARING_EVENT);
            break;
        case InProgress:
            if ( subTransferStarted.compareAndSet(false, true) ) {
                /* The first InProgress signal */
                fireProgressEvent(ProgressEventType.TRANSFER_STARTED_EVENT);
            }
            /* Don't need any event code update for subsequent InProgress signals */
            break;
        case Completed:
            fireProgressEvent(ProgressEventType.TRANSFER_COMPLETED_EVENT);
            break;
        case Canceled:
            fireProgressEvent(ProgressEventType.TRANSFER_CANCELED_EVENT);
            break;
        case Failed:
            fireProgressEvent(ProgressEventType.TRANSFER_FAILED_EVENT);
            break;
        default:
            break;
        }
    }
731627
public function next()
    {
        $this->position++;
        if (!$this->valid() && $this->nextPage) {
            $request = new \Paysafe\Request($this->nextPage);
            $this->nextPage = null;
            $response = $this->client->processRequest($request);
            $this->parseResponse($response);
        }
    }
423203
public void setWorkflowState(java.util.Collection<StringFilter> workflowState) {
        if (workflowState == null) {
            this.workflowState = null;
            return;
        }

        this.workflowState = new java.util.ArrayList<StringFilter>(workflowState);
    }
643410
protected function updateActionTransitions($actionTemplate, $action)
    {
        $transitions = array();
        if (isset($actionTemplate['transitions']) && is_array($actionTemplate['transitions'])) {
            $existing = $action->Transitions();
            $transitionMap = array();
            foreach ($existing as $transition) {
                $transitionMap[$transition->Title] = $transition;
            }

            foreach ($actionTemplate['transitions'] as $transitionName => $transitionTemplate) {
                $target = $transitionTemplate;
                if (is_array($transitionTemplate)) {
                    $to = array_keys($transitionTemplate);
                    $transitionName = $to[0];
                    $target = $transitionTemplate[$transitionName];
                }

                if (isset($transitionMap[$transitionName])) {
                    $transition = $transitionMap[$transitionName];
                } else {
                    $transition = WorkflowTransition::create();
                }

                // Add Member and Group relations to this Transition
                $this->addManyManyToObject($transition, $transitionTemplate);

                $transition->Title = $transitionName;
                $transition->ActionID = $action->ID;
                // we don't have the NextAction yet other than the target name, so we store that against
                // the transition and do a second pass later on to match things up
                $transition->Target = $target;
                $transitions[] = $transition;
            }
        }

        return $transitions;
    }
71246
function _go() {
        if(workers < concurrency) {
            var job = queue.shift();
            if(job !== undefined) {
                var worker = job.shift();
                job.push(over);
                workers++;
                process.nextTick(function nextTickWorker() {
                    worker.apply(null, job);
                });
                return true;
            }
        }
        return false;
    }