import 'platform:/resource/uk.ac.le.cs.moment2.tests.exogenous/20080617_AD2CSP_exogenous/csp.ecore';
import 'platform:/resource/uk.ac.le.cs.moment2.tests.exogenous/20080617_AD2CSP_exogenous/activity.ecore' ;

transformation Activity2Csp( source : activity ; target : csp)
{
	eq rule1ActivityCollection2CspContainer {
		lhs source {
			ac : ActivityCollection {
				name = acname
			} 
		};
		
		lhs target {};
		
		rhs source { 
			ac : ActivityCollection {
				name = acname
			}
		};

		rhs target {
			cspCont : CspContainer {
				name = acname,
				processAssignments = skipPA : ProcessAssignment {
					processIdentifier = skipPAprocessIdentifier : ProcessIdentifier {
						name = "SKIP"
					}
				}				
			} 		
		};		
		
		nac target noContainer {
			cspCont : CspContainer {
				name = acname
			} 
		};		
	}
	
	
	
	eq rule2ActivityEdge2ProcessIdentifier
	{
		lhs source { 
			inEdge : ActivityEdge {
				name = inEdgename
			}
		};
		lhs target {
			cspCont : CspContainer { }
		};		
		
		rhs source { 
			inEdge : ActivityEdge {
				name = inEdgename
			}
		};
		rhs target {
			cspCont : CspContainer {
				processAssignments = pa : ProcessAssignment {
					processIdentifier = sp : ProcessIdentifier {
						name = inEdgename
					}
				}
			} 
		};
		
		nac target noProcess { 			
			sp : ProcessIdentifier {
				name = inEdgename
			} 
		} ;
	}
	
	eq rule3FinalNode
	{
		lhs source { 
			inEdge : ActivityEdge {
				name = inEdgename,
				target = fNode : FinalNode { }
			}
		};
		lhs target {
			skipPAprocessIdentifier : ProcessIdentifier {
				name = "SKIP"
			}
			pPA : ProcessAssignment {
				processIdentifier = pPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				}
			}
		};
		
		rhs source { 
			inEdge : ActivityEdge {
				name = inEdgename
			}
		} ;
		rhs target {
			pPA : ProcessAssignment {
				processIdentifier = pPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = skipPAprocess : Process { 
					processIdentifier = skipPAprocessIdentifier : ProcessIdentifier {
						name = "SKIP"
					}
				}
			}
		};
	

	}	
		
	
	
	
	eq rule4Action2Event
	{
		lhs source { 
			inEdge : ActivityEdge {
				name = inEdgename,
				target = a : Action {}
			}
						
			a : Action { 
				name = aname
			}
				
			outEdge : ActivityEdge {
				name = outEdgename,
				source = a : Action {}
			}
		};
		lhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				}
			}
			outPAprocessIdentifier : ProcessIdentifier {
				name = outEdgename
			}
		};
		
		rhs source { 
		
			inEdge : ActivityEdge {
				name = inEdgename
			}
			
			outEdge : ActivityEdge {
				name = outEdgename
			}
		};
		rhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = inP : Prefix {
					targetProcess = inPtargetProcess : Process {
						processIdentifier = outPAprocessIdentifier : ProcessIdentifier { 
							name = outEdgename
						}
					},
					event = inPevent : Event {
						name = aname
					}
				}
			}
		};		
		
	}	

	

	
	
	
	eq rule5MergeNode2Assignments
	{
		lhs source {
		
			inEdge1 : ActivityEdge {
				name = inEdge1name,
				target = mn : MergeNode { }
			}
			inEdge2 : ActivityEdge {
				name = inEdge2name,
				target = mn : MergeNode { }
			}
			mn : MergeNode {
				name = mnname
			}
			outEdge : ActivityEdge {
				name = outEdgename,
				source = mn : MergeNode { }
			}
		};
		lhs target {
		
			inPA1 : ProcessAssignment {
				processIdentifier = inPA1processIdentifier : ProcessIdentifier {
					name = inEdge1name
				}
			}
			inPA2 : ProcessAssignment {
				processIdentifier = inPA2processIdentifier : ProcessIdentifier {
					name = inEdge2name
				}
			}
			outPAprocessIdentifier : ProcessIdentifier {
				name = outEdgename
			}
		};		
		
		rhs source {
			inEdge1 : ActivityEdge {
				name = inEdge1name
			}
			inEdge2 : ActivityEdge {
				name = inEdge2name
			}
			
			outEdge : ActivityEdge {
				name = outEdgename
			}
		};
		rhs target {
			inPA1 : ProcessAssignment {
				processIdentifier = inPA1processIdentifier : ProcessIdentifier {
					name = inEdge1name
				},
				process = inP1 : Process {
					processIdentifier = outPAprocessIdentifier : ProcessIdentifier { 
						name = outEdgename
					}
				}					
			}
			inPA2 : ProcessAssignment {
				processIdentifier = inPA2processIdentifier : ProcessIdentifier {
					name = inEdge2name
				},
				process = inP2 : Process {
					processIdentifier = outPAprocessIdentifier : ProcessIdentifier { 
						name = outEdgename
					}
				}					
			}
		};		

		
	}		
	
	



	eq rule6DecisionNodeElse2Assignments
	{
		lhs source {
		
			inEdge : ActivityEdge {
				name = inEdgename,
				target = dn : DecisionNode { }
			}
			outEdge : ActivityEdge {
				name = outEdgename,
				guard = outEdgeguard,
				source = dn : DecisionNode { }
			}
			outEdgeElse : ActivityEdge {
				name = outEdgeElsename,
				guard = "else",
				source = dn : DecisionNode { }
			}
		};
		lhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				}
			}
			outPAprocessIdentifier : ProcessIdentifier {
				name = outEdgename
			}
			outPAElseprocessIdentifier : ProcessIdentifier {
				name = outEdgeElsename
			}
		};
						
		rhs source {
			inEdge : ActivityEdge {
				name = inEdgename,
				target = dn : DecisionNode { }
			}
			outEdge : ActivityEdge {
				name = outEdgename
			}			
			outEdgeElse : ActivityEdge {
				name = outEdgeElsename,
				guard = "else",
				source = dn : DecisionNode { }
			}
		};
		rhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = c1 : Condition {
					expression = outEdgeguard,
					leftHandSide = c1leftHandSide : Process {
						processIdentifier = outPAprocessIdentifier : ProcessIdentifier { 
							name = outEdgename
						}
					}, 
					rightHandSide = c1rightHandSide : Process { 
						processIdentifier = outPAElseprocessIdentifier : ProcessIdentifier { 
							name = outEdgeElsename
						}
					}
				}
			}
		};
		
		
	}	


	eq rule7DecisionNode2Assignments
	{
		lhs source {
			inEdge : ActivityEdge {
				name = inEdgename,
				target = dn : DecisionNode { }
			}
			outEdge : ActivityEdge {
				name = outEdgename,
				guard = outEdgeguard,
				source = dn : DecisionNode { }
			}
			outEdgeElse : ActivityEdge {
				name = outEdgeElsename,
				guard = "else",
				source = dn : DecisionNode { }
			}
		};
		lhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = c1 : Condition {}
			}
			outPAprocessIdentifier : ProcessIdentifier {
				name = outEdgename
			}
		};
		
		rhs source {
			inEdge : ActivityEdge {
				name = inEdgename,
				target = dn : DecisionNode { }
			}	
			outEdge : ActivityEdge {
				name = outEdgename
			}
			outEdgeElse : ActivityEdge {
				name = outEdgeElsename,
				guard = "else",
				source = dn : DecisionNode { }
			}
		};
		rhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = c2 : Condition {
					expression = outEdgeguard,
					leftHandSide = c2lhs : Process { 
						processIdentifier = outPAprocessIdentifier : ProcessIdentifier {
							name = outEdgename
						}
					}, 
					rightHandSide = c1 : Condition { }
				}
			}			
		};
	}	











	eq rule8DecisionNodeDeletion
	{
		lhs source {
			inEdge : ActivityEdge {
				name = inEdgename,
				target = dn : DecisionNode { }
			}
			outEdgeElse : ActivityEdge {
				name = outEdgeElsename,
				guard = "else",
				source = dn : DecisionNode { }
			}
		};
		
		rhs source {
			inEdge : ActivityEdge {
				name = inEdgename
			}
			outEdgeElse : ActivityEdge {
				name = outEdgeElsename,
				guard = "else"
			}		
		};
		
		nac source processedDecisionNode {
			inEdge : ActivityEdge {
				name = inEdgename,
				target = dn : DecisionNode { }
			}
			outEdge : ActivityEdge {
				source = dn : DecisionNode { }
			}
			outEdgeElse : ActivityEdge {
				name = outEdgeElsename,
				guard = "else",
				source = dn : DecisionNode { }
			}
		};
	}

	eq rule9baseForkNode2Concurrency
	{
		lhs source {
		
			inEdge : ActivityEdge {
				name = inEdgename,
				target = fn : ForkNode { }
			}
			outEdge1 : ActivityEdge {
				name = outEdge1name,
				source = fn : ForkNode { }
			}
			outEdge2 : ActivityEdge {
				name = outEdge2name,
				source = fn : ForkNode { }
			}
		};
		lhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				}
			}	
			outPA1processIdentifier : ProcessIdentifier {
				name = outEdge1name
			}
			outPA2processIdentifier : ProcessIdentifier {
				name = outEdge2name
			}		
		};
		
		rhs source {

			inEdge : ActivityEdge {
				name = inEdgename,
				target = fn : ForkNode { }
			}
			outEdge1 : ActivityEdge {
				name = outEdge1name
			}
			outEdge2 : ActivityEdge {
				name = outEdge2name
			}
		};
		rhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = inPAprocess : Concurrency {
					leftHandSide = inPAprocesslhs : Process {
						processIdentifier = outPA1processIdentifier : ProcessIdentifier {
							name = outEdge1name
						}
					},
					rightHandSide = inPAprocessrhs : Process {
						processIdentifier = outPA2processIdentifier : ProcessIdentifier {
							name = outEdge2name
						}
					}
				}
			}
		};		
		


		nac target noConcurrency {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = cc : Concurrency { }
			}			
		};	
	}	

	eq rule10ForkNode2Concurrency
	{
		lhs source {
		
			inEdge : ActivityEdge {
				name = inEdgename,
				target = fn : ForkNode { }
			}
			outEdge1 : ActivityEdge {
				name = outEdge1name,
				source = fn : ForkNode { }
			}
		};
		lhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = inPAprocess : Concurrency { }
			}
			outPA1processIdentifier : ProcessIdentifier {
				name = outEdge1name
			}
		};
		
		rhs source {

			inEdge : ActivityEdge {
				name = inEdgename,
				target = fn : ForkNode { }
			}
			outEdge1 : ActivityEdge {
				name = outEdge1name
			}
		};
		rhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = inPAprocessnew : Concurrency {
					leftHandSide = inPAprocesslhs : Process {
						processIdentifier = outPA1processIdentifier : ProcessIdentifier {
							name = outEdge1name
						}
					},
					rightHandSide = inPAprocess : Concurrency { }
				}
			}	
		};
		
	}	

	eq rule11ForkNodeDeletion
	{
		lhs source {
			inEdge : ActivityEdge {
				name = inEdgename,
				target = fn : ForkNode { }
			}		
		};
		rhs source {
			inEdge : ActivityEdge {
				name = inEdgename
			}		
		};
		nac source ForkNodeAlreadyProcessed {
			inEdge : ActivityEdge {
				name = inEdgename
			}
			outEdge1 : ActivityEdge {
				source = fn : ForkNode { }
			}			
		};
	}
	

	eq rule12baseJoinNode2Event
	{
		lhs source {
		
			inEdge : ActivityEdge {
				name = inEdgename,
				target = jn : JoinNode { }
			}
			outEdge : ActivityEdge {
				name = outEdgename,
				source = jn : JoinNode { }
			}
		};
		lhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				}
			}	
			outPAprocessIdentifier : ProcessIdentifier {
				name = outEdgename
			}
		};		
		
		rhs source {
			inEdge : ActivityEdge {
				name = inEdgename
			}
			outEdge : ActivityEdge {
				name = outEdgename
			}
		};	
		rhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = inPAprocess : Prefix {
					targetProcess = inPAprocesstargetProcess : Process {
						processIdentifier = outPAprocessIdentifier : ProcessIdentifier { 
							name = outEdgename
						}
					},
					event = inPAprocessevent : Event {
						name = "joinProcess"
					}
				}				
			}	
		};		
		
		nac source onlyOneInEdge {
			inEdge : ActivityEdge {
				name = inEdgename,
				target = jn : JoinNode { }
			}
			inEdgeElse : ActivityEdge {
				target = jn : JoinNode { }
			}			
		};
		
	}	

	eq rule13JoinNode2Event
	{
		lhs source {
		
			inEdge : ActivityEdge {
				name = inEdgename,
				target = jn : JoinNode { }
			}
			inEdgeElse : ActivityEdge {
				name = inEdgeElsename,
				target = jn : JoinNode { }
			}
			outEdge : ActivityEdge {
				name = outEdgename,
				source = jn : JoinNode { }
			}
		};
		lhs target {
			skipprocessIdentifier : ProcessIdentifier {
				name = "SKIP"
			}
						
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				}
			}	
		};		
		
		rhs source {
			inEdge : ActivityEdge {
				name = inEdgename
			}
			inEdgeElse : ActivityEdge {
				name = inEdgeElsename,
				target = jn : JoinNode { }
			}			
			outEdge : ActivityEdge {
				name = outEdgename,
				source = jn : JoinNode { }
			}
		};	
		rhs target {
			inPA : ProcessAssignment {
				processIdentifier = inPAprocessIdentifier : ProcessIdentifier {
					name = inEdgename
				},
				process = inPAprocess : Prefix {
					targetProcess = inPAprocesstargetProcess : Process {
						processIdentifier = skipprocessIdentifier : ProcessIdentifier {
							name = "SKIP"
						}
					},
					event = inPAprocessevent : Event {
						name = "joinProcess"
					}
				}				
			}
		};		
			
	}	

	eq rule14DeleteActivityCollection  {
		lhs source {
			a : ActivityCollection { }
		};
		rhs source {};
		nac source onlyInitialNode {
			i : InitialNode{}
			other : ActivityNode{}
		} ;
		
	}

}