examples/org.eclipse.qvtd.examples.qvtrelation.hstm2fstm/model/HierarchicalStateMachine2FlatStateMachine.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 v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *     TCS - initial implementation for ModelMorf
 *     E.D.Willink - alignment with evolved specification
 *     E.D.Willink - rename / comment
 *******************************************************************************/
import hierMM : 'HierarchicalStateMachine.ecore'::HierarchicalStateMachine; 
import flatMM : 'FlatStateMachine.ecore'::FlatStateMachine; 

/**
 * Transform a hierarchical StateMachine into a flat StateMachine.
 */
transformation org::eclipse::qvtd::examples::qvtrelation::hstm2fstm::HierarchicalStateMachine2FlatStateMachine(hier:hierMM, flat:flatMM)
{
--	key hierMM::State {name};
--	key hierMM::Trans {name, fromState, toState};
--	key flatMM::State {name};
--	key flatMM::Trans {name, fromState, toState};

	/**
	 * Return the leafStates of a given hierarchicalState.
	 */
	query getLeafStates(hierarchicalState : hierMM::State[1]) : Set(hierMM::State) {
		hierarchicalState->closure(nestedStates)?->select(nestedStates->isEmpty())
	}

	/**
	 *  Map each hierarchical StateMachine to a flat StateMachine
	 */
	top relation HierachicalStateMachine2FlatStateMachine {
		domain hier hierarchicalStateMachine : StateMachine {
			name = stateMachineName : String{}
		};	   
		enforce domain flat flatStateMachine : StateMachine {
			name = stateMachineName
		};
	}   

	/**
	 *  Map each Leaf State to a Flat State in the corresponding StateMachine.
	 */
	top relation LeafState2FlatState {
		domain hier leafState : State {
			owningStateMachine = hierarchicalStateMachine : hierMM::StateMachine{},
	   		name = stateName : String{}
		} {leafState.nestedStates->isEmpty()};
	   
		enforce domain flat flatState : State {
			owningStateMachine = flatStateMachine : StateMachine{},
			name = stateName
		};	
		when {
			HierachicalStateMachine2FlatStateMachine(hierarchicalStateMachine, flatStateMachine);
		}
	}   

	/**
	 *  Map each hierarchical Transition to a Flat Transition in the corresponding StateMachine
	 *  for each combination of possible leaf end states
	 */
	top relation HierachicalTransition2FlatTransition
	{
		leafFromStates : Set(hierMM::State) = hierarchicalFromState->closure(nestedStates)->select(nestedStates->isEmpty());
		leafToStates : Set(hierMM::State) = hierarchicalToState->closure(nestedStates)->select(nestedStates->isEmpty());
		leafFromState : hierMM::State[1];
		leafToState : hierMM::State[1];
		domain hier hierarchicalTransition : Transition {
			owningStateMachine = hierarchicalStateMachine : StateMachine{},
			name = transitionName : String{},
			fromState = hierarchicalFromState : State{},
			toState = hierarchicalToState : State{}
		};
		enforce domain flat flatTransition : Transition {
			owningStateMachine = flatStateMachine : StateMachine{},
			name = transitionName,
			fromState = flatFromState : State{},
			toState = flatToState : State{}
		};
		when {
			HierachicalStateMachine2FlatStateMachine(hierarchicalStateMachine, flatStateMachine);
			LeafState2FlatState(leafFromState, flatFromState);
			LeafState2FlatState(leafToState, flatToState);
			leafFromStates->includes(leafFromState);
			leafToStates->includes(leafToState);
		}
	}
}