Method GetExecutableTransition

Modules/Core/src/Interactions/mitkEventStateMachine.cpp:202–280

}

mitk::StateMachineTransition *mitk::EventStateMachine::GetExecutableTransition(mitk::InteractionEvent *event)
{
  // Map that will contain all conditions that are possibly used by the
  // transitions
  std::map<std::string, bool> conditionsMap;

  // Get a list of all transitions that match the given event
  const mitk::StateMachineState::TransitionVector transitionList =
    m_CurrentState->GetTransitionList(event->GetNameOfClass(), MapToEventVariant(event));

  // if there are not transitions, we can return nullptr here.
  if (transitionList.empty())
  {
    return nullptr;
  }

  StateMachineState::TransitionVector::const_iterator transitionIter;
  ConditionVectorType::const_iterator conditionIter;
  for (transitionIter = transitionList.cbegin(); transitionIter != transitionList.cend(); ++transitionIter)
  {
    bool allConditionsFulfilled(true);

    // Get all conditions for the current transition
    const ConditionVectorType conditions = (*transitionIter)->GetConditions();
    for (conditionIter = conditions.cbegin(); conditionIter != conditions.cend(); ++conditionIter)
    {
      bool currentConditionFulfilled(false);

      // sequentially check all conditions that we have evaluated above
      const std::string conditionName = (*conditionIter).GetConditionName();

      // Check if the condition has already been evaluated
      if (conditionsMap.find(conditionName) == conditionsMap.cend())
      {
        // if the condition has not been evaluated yet, do it now and store
        // the result in the map
        try
        {
          currentConditionFulfilled = CheckCondition((*conditionIter), event);
          conditionsMap.insert(std::pair<std::string, bool>(conditionName, currentConditionFulfilled));
        }
        catch (const std::exception &e)
        {
          MITK_ERROR << "Unhandled exception caught in CheckCondition(): " << e.what();
          currentConditionFulfilled = false;
          break;
        }
        catch (...)
        {
          MITK_ERROR << "Unhandled exception caught in CheckCondition()";
          currentConditionFulfilled = false;
          break;
        }
      }
      else
      {
        // if the condition has been evaluated before, use that result
        currentConditionFulfilled = conditionsMap[conditionName];