tests/org.eclipse.qvtd.build.qvtrtoqvtc.tests/src/org/eclipse/qvtd/build/qvtrtoqvtc/tests/seqtostm/SeqToStm.qvtr

/*******************************************************************************
 * Copyright (c) 2007,2008 Tata Consultancy Services and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     TCS - initial implementation for ModelMorf
 *     E.D.Willink - alignment with evolved specification
 *******************************************************************************/
import SeqMM : 'SeqMM.emof'::SeqMM; 
import StmcMM : 'StmcMM.emof'::StmcMM; 

transformation SeqToStm(seqDgm: SeqMM, stm: StmcMM)
{
     key StmcMM::StateMachine{name};
     key StmcMM::State{name,owner};
     key StmcMM::Transition{name,owner,fromState,toState};
     key StmcMM::SendMsg{message};
     key StmcMM::Message{messageId};

     top relation InteractionToStateMachine
     {
          sn: String;

          domain seqDgm i:Interaction {name = sn};
          enforce domain stm s:StateMachine {name = sn};
     }
     
     top relation StateToState
     {
          sn: String;

          domain seqDgm 
          st1:State 
          {
               name = sn,
               lifeline = l:LifeLine{interaction = i:Interaction{}}
          };

          enforce domain stm 
          st2:State 
          {
               name = sn,
               owner = s:StateMachine{}
          };

          when
          {
               InteractionToStateMachine(i, s);
          }
     }
     
     top relation MessageToTransition
     {
          mid: String;

          domain seqDgm 
          m1:Message 
          {
               messageId = mid,
--               event = send:MessageEvent {type = MessageEventType::Send, state = ist1:State{}},
--               event = receive:MessageEvent {type = MessageEventType::Receive, state = ist2:State{}},
               event = eSet:Set(MessageEvent) {
                   send:MessageEvent {type = MessageEventType::Send, state = ist1:State{}},
                   receive:MessageEvent {type = MessageEventType::Receive, state = ist2:State{}}
                   ++ _
               },
               interaction = i:Interaction{}
          };

          enforce domain stm 
          tr:Transition
          {
               name = mid,
               fromState = fst:State{},
               toState = tst:State{},
               action = sm:SendMsg {message = m2:Message{messageId = mid}},
               owner = s:StateMachine{}
          };

          when
          {
               InteractionToStateMachine(i, s);
               StateToState(ist1, fst);
               StateToState(ist2, tst);
          }
     }
     
     top relation MessageSequenceToTransitionSequence
     {
          domain seqDgm 
          ev1:MessageEvent 
          {
               type = MessageEventType::Receive,
               message = m1:Message{},
               state = est:State{},
               next = ev2:MessageEvent{type=MessageEventType::Send, message=m2:Message{}}
          };

          enforce domain stm 
          tr1:Transition
          {
               toState = tst:State{outTransition = tr2:Transition{}}
          };

          when
          {
               StateToState(est, tst);  -- Added to get the correct tst:State
               MessageToTransition(m1, tr1);
               MessageToTransition(m2, tr2);
          }
     }

}