void PolicyView::drawArrows(QPainter * p) { p->setPen(darkGreen); // get list with transitions // TransitionVector transitions = policy_->transitions(); const int Zeilenabstand=10; int DrawX1 = std::max(contentsWidth(), visibleWidth()); int DrawY1 = 0; int i; // show all transitions // QMap<PatternXML *, int> map; TransitionVector::iterator first, last = transitions.end(); for (first = transitions.begin(); first != last; ++first ) { QString message = first->getMessage(); PatternXML * target = first->getTarget(); map[target] = map[target] + 1; int DrawX2 = childX(target->widget()) + target->widget()->width(); int DrawY2 = childY(target->widget()); PatternWidget::drawArrow(p, DrawX1, DrawY1, DrawX2, DrawY2, 10); i = map[target]-1; p->drawText((DrawX1 + DrawX2) / 2, (DrawY1 + DrawY2) /2 + i * Zeilenabstand, message); } }
mitk::StateMachineState::TransitionVector mitk::StateMachineState::GetTransitionList( const std::string& eventClass, const std::string& eventVariant) { TransitionVector transitions; mitk::StateMachineTransition::Pointer t = mitk::StateMachineTransition::New("", eventClass, eventVariant); for (TransitionVector::iterator it = m_Transitions.begin(); it != m_Transitions.end(); ++it) { if (**it == *t) // do not switch it and t, order matters, see mitk::StateMachineTransition == operator transitions.push_back( *it ); } return transitions; }
mitk::StateMachineTransition::Pointer mitk::StateMachineState::GetTransition( const std::string& eventClass, const std::string& eventVariant) { TransitionVector transitions = this->GetTransitionList( eventClass, eventVariant ); if ( transitions.size() > 1 ) { MITK_WARN << "Multiple transitions have been found for event. Use non-deprecated method StateMachineState::GetTransitionList() instead!"; } if ( transitions.empty() ) { return NULL; } else { return transitions.at(0); } }
void AbstractValue::observeTransitions(const TransitionVector& vector) { if (m_type & SpecCell) { m_structure.observeTransitions(vector); ArrayModes newModes = 0; for (unsigned i = vector.size(); i--;) { if (m_arrayModes & asArrayModes(vector[i].previous->indexingType())) newModes |= asArrayModes(vector[i].next->indexingType()); } m_arrayModes |= newModes; } checkConsistency(); }
void StructureAbstractValue::observeTransitions(const TransitionVector& vector) { SAMPLE("StructureAbstractValue observeTransitions"); if (isTop()) return; StructureSet newStructures; for (unsigned i = vector.size(); i--;) { ASSERT(!vector[i].previous->dfgShouldWatch()); if (!m_set.contains(vector[i].previous)) continue; newStructures.add(vector[i].next); } if (!m_set.merge(newStructures)) return; if (m_set.size() > polymorphismLimit) makeTop(); }
void copyState( ESMoL::State inputState, ESMoL::State outputState ) { UdmEngine::copyState( inputState, outputState ); TransStartVector transStartVector = inputState.TransStart_kind_children(); for( TransStartVector::iterator tsvItr = transStartVector.begin() ; tsvItr != transStartVector.end() ; ++tsvItr ) { ESMoL::TransStart inputTransStart = *tsvItr; ESMoL::TransStart outputTransStart = ESMoL::TransStart::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputTransStart, outputTransStart ) ); } DataVector dataVector = inputState.Data_kind_children(); for( DataVector::iterator dtvItr = dataVector.begin() ; dtvItr != dataVector.end() ; ++dtvItr ) { copyData( *dtvItr, ESMoL::Data::Create( outputState ) ); } EventVector eventVector = inputState.Event_kind_children(); for( EventVector::iterator envItr = eventVector.begin() ; envItr != eventVector.end() ; ++envItr ) { copyEvent( *envItr, ESMoL::Event::Create( outputState ) ); } JunctionVector junctionVector = inputState.Junction_kind_children(); for( JunctionVector::iterator jnvItr = junctionVector.begin() ; jnvItr != junctionVector.end() ; ++jnvItr ) { ESMoL::Junction inputJunction = *jnvItr; ESMoL::Junction outputJunction = ESMoL::Junction::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputJunction, outputJunction ) ); } StateVector stateVector = inputState.State_kind_children(); for( StateVector::iterator stvItr = stateVector.begin() ; stvItr != stateVector.end() ; ++stvItr ) { ESMoL::State inputSubState = *stvItr; ESMoL::State outputSubState = ESMoL::State::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputSubState, outputSubState ) ); copyState( inputSubState, outputSubState ); } ConnectorRefVector connectorRefVector = inputState.ConnectorRef_kind_children(); for( ConnectorRefVector::iterator jnvItr = connectorRefVector.begin() ; jnvItr != connectorRefVector.end() ; ++jnvItr ) { ESMoL::ConnectorRef inputConnectorRef = *jnvItr; ESMoL::ConnectorRef outputConnectorRef = ESMoL::ConnectorRef::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputConnectorRef, outputConnectorRef ) ); getConnectorRefList().push_back( inputConnectorRef ); } TransitionVector transitionVector = inputState.Transition_kind_children(); for( TransitionVector::iterator trvItr = transitionVector.begin() ; trvItr != transitionVector.end() ; ++trvItr ) { ESMoL::Transition inputTransition = *trvItr; ESMoL::TransConnector inputSrcTransConnector = inputTransition.srcTransition_end(); TransConnectorMap::iterator tcmItr = getTransConnectorMap().find( inputSrcTransConnector ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "WARNING: transconnector does not map to copy" << std::endl; continue; } ESMoL::TransConnector outputSrcTransConnector = tcmItr->second; ESMoL::TransConnector inputDstTransConnector = inputTransition.dstTransition_end(); tcmItr = getTransConnectorMap().find( inputDstTransConnector ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "WARNING: transconnector does not map to copy" << std::endl; continue; } ESMoL::TransConnector outputDstTransConnector = tcmItr->second; ESMoL::Transition outputTransition = ESMoL::Transition::Create( outputState ); UdmEngine::copyTransition( inputTransition, outputTransition ); outputTransition.srcTransition_end() = outputSrcTransConnector; outputTransition.dstTransition_end() = outputDstTransConnector; } }