Retrieves the successor state reached via a given action. If no transition
is triggered by this action, <tt>null</tt> is returned.
@param action the action
@return the successor state reached via the specified action, or <tt>null</tt>
971699
public DuzztState getSuccessor(DuzztAction action) {
		DuzztTransition t = getTransition(action);
		if(t == null) {
			return null;
		}
		return t.getSuccessor();
	}
579374
public I_CmsListDirectAction getDirectAction(String actionId) {

        Iterator<I_CmsListDirectAction> it = m_directActions.iterator();
        while (it.hasNext()) {
            I_CmsListDirectAction action = it.next();
            if (action.getId().equals(actionId)) {
                return action;
            }
        }
        return null;
    }
689145
def getTransitionActor(obj, action_id):
    
    review_history = getReviewHistory(obj)
    for event in review_history:
        if event.get('action') == action_id:
            return event.get('actor')
    return None
1055515
static ContinuableFuture<Void> execute(final Try.Runnable<? extends Exception> action) {
        return execute(new FutureTask<Void>(FN.toCallable(action)), SERIAL_EXECUTOR);
    }
265202
public Api getActionResult(String action, String params) throws Exception {
    Api result = this.getActionResult(action, params, null, null);
    return result;
  }
89707
public function getByAction($action)
    {
        return isset($this->actions[$action]) ? $this->actions[$action] : null;
    }
1115732
public static <T1> Func1<T1, Void> toFunc(final Action1<T1> action) {
        return toFunc(action, (Void) null);
    }
1275592
@Nullable
    public Transition getTransitionAt(int index) {
        if (index < 0 || index >= mTransitions.size()) {
            return null;
        }
        return mTransitions.get(index);
    }
1270998
@NotNull
    public Optional<T> executeIfAbsent(@NotNull Runnable action) {
        if (value == null)
            action.run();
        return this;
    }
529902
public function next(string $action = null): string
    {
        $this->message = $this->handle($action);

        if ($this->message instanceof Dispatcher)
        {
            return $this->message->next();
        }

        $response = $this->message;

        if (!($response instanceof MessageInterface))
        {
            $stream   = $this->factory->stream->createStream($response);
            $response = $this->message()->withBody($stream);
        }

        $this->setMessage($response);

        return (string)$this;
    }
1360543
private ModelActionEntry pollAction()
    {
        ModelActionEntry action = null;
        
        while(!stop) {
           
            synchronized(actionQueue) {
                action = this.actionQueue.poll();
            }
            
            if (action != null) {
                break;
            }
            else {
                synchronized(semaphore) {
                    try {
                        semaphore.wait();
                    } catch (InterruptedException ex) {
                        ex.printStackTrace(); //////////
                    }
                }
            }

        }
        
        return action;
        
    }
1209523
public final @CheckForNull QueueTaskFuture<RunT> scheduleBuild2(int quietPeriod, Action... actions) {
        Queue.Item i = scheduleBuild2(quietPeriod, Arrays.asList(actions));
        return i != null ? (QueueTaskFuture) i.getFuture() : null;
    }
52240
@Override
    public void tryUnchecked(ActionToTry<E> action) {
        tryUnchecked(noParam -> {
            action.execute();
            return null;
        }, null);
    }
313281
public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Void> toFunc(
            final Action6<T1, T2, T3, T4, T5, T6> action) {
        return toFunc(action, (Void) null);
    }
284796
@Override
    public boolean validateAction(String action) {
        boolean result = false;
        if (action.equals(MessagingSecurityConstants.OPERATION_TYPE_SEND) ||
            action.equals(MessagingSecurityConstants.OPERATION_TYPE_RECEIVE)) {
            result = true;
        }
        return result;
    }
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;
    }
626641
public void updateAction(Action action)
	{
		action.putValue(Action.NAME, myMessageProvider.getMessage(getLabelMessage(), getLocale()));
		action.putValue(Action.SHORT_DESCRIPTION, myMessageProvider.getMessage(getLabelDescription(), getLocale()));
		if (IS_NOT_EMPTY.test(getKeyboardShortcut()))
		{
			action.putValue(Action.ACCELERATOR_KEY, KeyboardRepresentationTable.getKeyStroke(getKeyboardShortcut()));
		}
		else
		{
			action.putValue(Action.ACCELERATOR_KEY, null);
		}
	}