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;
}
}
