Builds the collection of transitions for all event attributes defined on
 the given object.  This will only include events whose machine actions
 match the one specified.

 These should only be fired as a result of the action being run.
329407
def transitions(object, action, options = {})
      transitions = map do |name, machine|
        machine.events.attribute_transition_for(object, true) if machine.action == action
      end

      AttributeTransitionCollection.new(transitions.compact, {use_transactions: resolve_use_transactions}.merge(options))
    end
821496
def collect(self, attrs):
        """"""

        for name, value in attrs.items():
            if self.should_collect(value):
                transition = self.workflow.transitions[value.trname]

                if (
                        value.trname in self.implementations
                        and value.trname in self.custom_implems
                        and name != self.transitions_at[value.trname]):
                    # We already have an implementation registered.
                    other_implem_at = self.transitions_at[value.trname]
                    raise ValueError(
                        "Error for attribute %s: it defines implementation "
                        "%s for transition %s, which is already implemented "
                        "at %s." % (name, value, transition, other_implem_at))

                implem = self.add_implem(transition, name, value.func)
                self.custom_implems.add(transition.name)
                if value.check:
                    implem.add_hook(Hook(HOOK_CHECK, value.check))
                if value.before:
                    implem.add_hook(Hook(HOOK_BEFORE, value.before))
                if value.after:
                    implem.add_hook(Hook(HOOK_AFTER, value.after))
548145
def each_new_event
      new_events = []
      stack.events.each do |event|
        break if event.id == @last_processed_event_id
        new_events.unshift(event)
      end
      new_events.each do |event|
        yield event
        @last_processed_event_id = event.id
      end
    rescue Aws::CloudFormation::Errors::ValidationError => _e
    end
935446
private static void checkTransition(Map<Transition, Collection<TileRef>> transitions,
                                        MapTransitionExtractor extractor,
                                        Tile tile)
    {
        final Transition transition = extractor.getTransition(tile);
        if (transition != null)
        {
            getTiles(transitions, transition).add(new TileRef(tile));

            final Transition symetric = new Transition(transition.getType().getSymetric(),
                                                       transition.getOut(),
                                                       transition.getIn());
            getTiles(transitions, symetric).add(new TileRef(tile));
        }
    }
1283999
def _find_workflows(mcs, attrs):
        
        workflows = {}
        for attribute, value in attrs.items():
            if isinstance(value, Workflow):
                workflows[attribute] = StateField(value)
        return workflows
618769
void createTransitionInstances(ProcessInstance processInstanceVO,
            List<Transition> transitions, Long fromActInstId)
           throws ProcessException,DataAccessException {
        TransitionInstance transInst;
        for (Transition transition : transitions) {
            try {
                if (tooManyMaxTransitionInstances(transition, processInstanceVO.getId())) {
                    // Look for a error transition at this time
                    // In case we find it, raise the error event
                    // Otherwise do not do anything
                    handleWorkTransitionError(processInstanceVO, transition.getId(), fromActInstId);
                } else {
                    transInst = createTransitionInstance(transition, processInstanceVO.getId());
                    String tag = logtag(processInstanceVO.getProcessId(),
                            processInstanceVO.getId(), transInst);
                    logger.info(tag, "Transition initiated from " + transition.getFromId() + " to " + transition.getToId());

                    InternalEvent jmsmsg;
                    int delay = 0;
                    jmsmsg = InternalEvent.createActivityStartMessage(
                            transition.getToId(), processInstanceVO.getId(),
                            transInst.getTransitionInstanceID(), processInstanceVO.getMasterRequestId(),
                            transition.getLabel());
                    delay = transition.getTransitionDelay();
                    String msgid = ScheduledEvent.INTERNAL_EVENT_PREFIX + processInstanceVO.getId()
                            + "start" + transition.getToId() + "by" + transInst.getTransitionInstanceID();
                    if (delay>0) this.sendDelayedInternalEvent(jmsmsg, delay, msgid, false);
                    else sendInternalEvent(jmsmsg);
                }
            } catch (SQLException ex) {
                throw new ProcessException(-1, ex.getMessage(), ex);
            } catch (MdwException ex) {
                throw new ProcessException(-1, ex.getMessage(), ex);
            }
        }
    }
366520
private ParallelTransition buildSlideTransition(final boolean isReverse, final SlideModel<SlideStep> previousSlideModel, final SlideModel<SlideStep> selectedSlideModel) {
        final ParallelTransition slideAnimation = ParallelTransitionBuilder.create().build();

        if (previousSlideModel != null) {
            final Animation a = isReverse ? previousSlideModel.getShowAnimation() : previousSlideModel.getHideAnimation();
            if (a != null) {
                slideAnimation.getChildren().add(a);
            }
        }
        if (this.selectedSlideModel != null) {
            final Animation a = isReverse ? this.selectedSlideModel.getHideAnimation() : this.selectedSlideModel.getShowAnimation();
            if (a != null) {
                slideAnimation.getChildren().add(a);
            }
        }

        final SlideModel<SlideStep> csm = selectedSlideModel;
        // final SlideModel<SlideStep> psm = previousSlideModel;
        slideAnimation.setOnFinished(new javafx.event.EventHandler<ActionEvent>() {

            @Override
            public void handle(final ActionEvent arg0) {
                // // Hide previous slide
                // if (psm != null) {
                // getView().getRootNode().getChildren().removeAll(psm.getRootNode());
                // }

                // FIX ME NOT APPROPRIATED !!!
                if (previousSlideModel instanceof AbstractBaseModel) {
                    ((AbstractBaseModel<?>) previousSlideModel).doHideView(null);
                }
                if (selectedSlideModel instanceof AbstractBaseModel) {
                    ((AbstractBaseModel<?>) selectedSlideModel).doShowView(null);
                }

                // Hide all other slides
                if (csm != null) {
                    Node node;
                    for (int i = view().node().getChildren().size() - 1; i >= 0; i--) {
                        node = view().node().getChildren().get(i);
                        if (csm.node() != node) {
                            view().node().getChildren().remove(node);
                        }
                    }
                }
            }
        });
        return slideAnimation;
    }
165983
public function getTransitions($object, $graph = 'default', $asObject = false)
    {
        if (!$asObject) {
            return $this->getStateMachine($object, $graph)->getCurrentState()->getTransitions();
        }

        $stateMachine = $this->getStateMachine($object, $graph);

        return array_map(
            function ($transition) use ($stateMachine) {
                return $stateMachine->getTransition($transition);
            },
            $stateMachine->getCurrentState()->getTransitions()
        );
    }
1002942
def define_event_transition(event_name, silent)
      machine.send(:define_singleton_method, event_name) do |*data, &block|
        method = silent ? :transition : :trigger
        machine.public_send(method, event_name, *data, &block)
      end
    end
1184531
public synchronized void transitionEvent(boolean isEmpty)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "transitionEvent", new Object[]{ new Boolean(isEmpty)});

    if(isEmpty)
    {
      transition--;
    }
    else
    {
      transition++;
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "transitionEvent", new Integer(transition));
  }
922181
def use_event_attributes?
        !skip_actions && !skip_after && actions.all? && actions.length == 1 && first.machine.action_hook?
      end
842363
public Transition getNextTransition(ExecutionElement currentElem, List<ExecutionElement> peerExecutionElements, ExecutionStatus currentStatus)
			throws IllegalTransitionException {
		final String method = "getNextTransition";

		if (logger.isLoggable(Level.FINE)) {
			logger.fine(method + " ,currentStatus=" + currentStatus);
		}

		Transition returnTransition = new TransitionImpl();

		ExecutionElement nextExecutionElement = null;

		List<TransitionElement> transitionElements = currentElem.getTransitionElements();

		// Check the transition elements first.
		if (!transitionElements.isEmpty()) {
			for (TransitionElement t : transitionElements) {
				logger.fine(method + " Trying to match next transition element: " + t);

				boolean isMatched = matchExitStatusAgainstOnAttribute(currentStatus.getExitStatus(), t);
				if (isMatched) {
					if (t instanceof Next) {
						Next next = (Next)t;
						nextExecutionElement = getExecutionElementFromId(peerExecutionElements, next.getTo());
						returnTransition.setNextExecutionElement(nextExecutionElement);
						break;
					} else {
						returnTransition.setTransitionElement(t);
					}
					return returnTransition;
				}
			}
		}

		// We've returned already if we matched a Stop, End or Fail
		if (nextExecutionElement == null) {
			if (currentStatus.getExtendedBatchStatus().equals(ExtendedBatchStatus.EXCEPTION_THROWN)) {
				logger.fine("Didn't match transition element, after exception thrown.  Need to fail job");
				returnTransition.setNoTransitionElementMatchAfterException();
				return returnTransition;
			} else {
				logger.fine("Didn't match transition element, check @next attribute now.");
				nextExecutionElement = getNextExecutionElemFromAttribute(peerExecutionElements, currentElem);
				returnTransition.setNextExecutionElement(nextExecutionElement);
			}
		}

		if (nextExecutionElement != null) {
			if (alreadyExecutedElements.containsKey(nextExecutionElement.getId())) {
				String errorMsg = "Execution loop detected !!!  Trying to re-execute execution element: " + nextExecutionElement.getId();
				logger.severe(errorMsg);
				throw new IllegalTransitionException(errorMsg);
			}

			if (!disallowDecisionLoopback) {
				// We allow repeating a decision
				if (!(nextExecutionElement instanceof Decision)) {
					alreadyExecutedElements.put(nextExecutionElement.getId(), nextExecutionElement);
				}
			} else {
				alreadyExecutedElements.put(nextExecutionElement.getId(), nextExecutionElement);
			}
			logger.fine(method + " Transitioning to next element id = " + nextExecutionElement.getId());
		} else {
			logger.fine(method + " There is no next execution element. Mark transition to show we're finished.");
			returnTransition.setFinishedTransitioning();
		}
		return returnTransition;
	}
1153861
public List<com.ibm.jbatch.jsl.model.helper.TransitionElement> getTransitionElements() {
    return new ArrayList<com.ibm.jbatch.jsl.model.helper.TransitionElement>();
}
1339134
def to_transitions(self) -> 'Transitions':
        
        # No need to propagate 'rollout_tensors' as they won't mean anything
        return Transitions(
            size=self.num_steps * self.num_envs,
            environment_information=
                [ei for l in self.environment_information for ei in l]
                if self.environment_information is not None else None,
            transition_tensors={
                name: tensor_util.merge_first_two_dims(t) for name, t in self.transition_tensors.items()
            },
            extra_data=self.extra_data
        )
314070
def get_all_transitions(self, instance_cls):
        
        transitions = self.transitions[instance_cls]

        for name, transition in transitions.items():
            meta = transition._django_fsm

            for transition in meta.transitions.values():
                yield transition
932912
function(moveData) {
            var self            = this,
                transitionRules = [],
                transformValues = [],
                isResizing      = self.mixer.config.animation.animateResizeTargets,
                isFading        = typeof self.mixer.effectsIn.opacity !== 'undefined';

            self.callActions('beforeApplyStylesOut', arguments);

            // Build the transition rules

            transitionRules.push(self.writeTransitionRule(
                mixitup.features.transformRule,
                moveData.staggerIndex
            ));

            if (moveData.statusChange !== 'none') {
                transitionRules.push(self.writeTransitionRule(
                    'opacity',
                    moveData.staggerIndex,
                    moveData.duration
                ));
            }

            if (isResizing) {
                transitionRules.push(self.writeTransitionRule(
                    'width',
                    moveData.staggerIndex,
                    moveData.duration
                ));

                transitionRules.push(self.writeTransitionRule(
                    'height',
                    moveData.staggerIndex,
                    moveData.duration
                ));

                transitionRules.push(self.writeTransitionRule(
                    'margin',
                    moveData.staggerIndex,
                    moveData.duration
                ));
            }

            // If no callback was provided, the element will
            // not transition in any way so tag it as "immovable"

            if (!moveData.callback) {
                self.mixer.targetsImmovable++;

                if (self.mixer.targetsMoved === self.mixer.targetsImmovable) {
                    // If the total targets moved is equal to the
                    // number of immovable targets, the operation
                    // should be considered finished

                    self.mixer.cleanUp(moveData.operation);
                }

                return;
            }

            // If the target will transition in some fasion,
            // assign a callback function

            self.operation = moveData.operation;
            self.callback = moveData.callback;

            // As long as the target is not excluded, increment
            // the total number of targets bound

            !self.isExcluded && self.mixer.targetsBound++;

            // Tag the target as bound to differentiate from transitionEnd
            // events that may come from stylesheet driven effects

            self.isBound = true;

            // Apply the transition

            self.applyTransition(transitionRules);

            // Apply width, height and margin negation

            if (isResizing && moveData.posOut.width > 0 && moveData.posOut.height > 0) {
                self.dom.el.style.width        = moveData.posOut.width + 'px';
                self.dom.el.style.height       = moveData.posOut.height + 'px';
                self.dom.el.style.marginRight  = moveData.posOut.marginRight + 'px';
                self.dom.el.style.marginBottom = moveData.posOut.marginBottom + 'px';
            }

            if (!self.mixer.config.animation.nudge && moveData.statusChange === 'hide') {
                // If we're not nudging, the translation should be
                // applied before any other transforms to prevent
                // lateral movement

                transformValues.push('translate(' + moveData.posOut.x + 'px, ' + moveData.posOut.y + 'px)');
            }

            // Apply fade

            switch (moveData.statusChange) {
                case 'hide':
                    isFading && (self.dom.el.style.opacity = self.mixer.effectsOut.opacity);

                    transformValues = transformValues.concat(self.mixer.transformOut);

                    break;
                case 'show':
                    isFading && (self.dom.el.style.opacity = 1);
            }

            if (
                self.mixer.config.animation.nudge ||
                (!self.mixer.config.animation.nudge && moveData.statusChange !== 'hide')
            ) {
                // Opposite of above - apply translate after
                // other transform

                transformValues.push('translate(' + moveData.posOut.x + 'px, ' + moveData.posOut.y + 'px)');
            }

            // Apply transforms

            self.dom.el.style[mixitup.features.transformProp] = transformValues.join(' ');

            self.callActions('afterApplyStylesOut', arguments);
        }
1073741
def _make_transitions(self) -> List[Transition]:
        

        module_name = settings.TRANSITIONS_MODULE
        module_ = importlib.import_module(module_name)
        return module_.transitions