Synchronization of Scenarios

T_Car[1] role car end

association Post_dmAct8_mileage_Car between

Post_dmAct8[*] role postSnapshot_dmAct8_mileage_Car T_RealCls[1] role mileage_Car

end

!set adaRental.finish:=finishDate

!set adaRental.pickedUp:=true

!insert (ada,adaRental) into Registration

!insert (adaRental,bmw) into UsingCar

---Begin Use Case ReturnCar

---!let matchSL = Tuple{actUC:actUC,preSnapshotUC:defaultSnapshot}

!let matchTL = Tuple{actDM:actDM,preSnapshotDM:defaultSnapshot}

!let matchCL = Tuple{corrAct:corrAct}

read uc2dm_start_coEvol.cmd

---NEXT_ActorAct1 ---Post_EnterCustInfo

!create postSnapshot_EnterCustInfo:Post_EnterCustInfo

!create id_Cust:T_StringCls

!set id_Cust.name:=’id_Cust’

!insert(postSnapshot_EnterCustInfo,id_Cust) into Post_EnterCustInfo_id_Cust

---Match SysState

!create idCustStr:StringCls

!set idCustStr.string:=’ada’

!set id_Cust.value:=idCustStr

---Execution

!let currExec=ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let _actorAct_name=’RequireCarReturn’

!let _nextDmAct_name=’getRentalInfo’

!let matchSL = Tuple{

ucAct:ucAct,actUC:actUC,preSnapshotUC:defaultSnapshot, postSnapshotUC:postSnapshot_EnterCustInfo,

_actorAct_name:_actorAct_name}

!let matchTL = Tuple{dmAct:dmAct,actDM:actDM,

postSnapshotDM:defaultSnapshot,_nextDmAct_name:_nextDmAct_name}

!let matchCL = Tuple{currExec:currExec}

read uc2dm_nextActorAct_coEvol.cmd

---NEXT_SysAct2 ---Pre/Postcondition_UC

---Pre/Postcondition_DM

!create preSnapshot_dmAct2:Pre_dmAct2

!create cust:T_Customer

!set cust.name:=’cust’

!insert (preSnapshot_dmAct2,cust) into Pre_dmAct2_cust

!insert (preSnapshot_dmAct2,id_Cust) into Pre_dmAct2_id_Cust

---Match SysState

!set cust.value:=Customer.allInstances->any(id=id_Cust.value.string) ---Execution

!let currExec=ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!create retCar:T_ReturningCar

!let _actGrp_opName=’getRentalInfo()’

!let _sysAct_name=’RetrieveRentalInfo’

!let _nextDmAct_name=’getCustomer’

!let matchSL=Tuple{

ucAct:ucAct,actUC:actUC,preSnapshotUC:defaultSnapshot, postSnapshotUC:defaultSnapshot,_sysAct_name:_sysAct_name}

!let matchTL=Tuple{dmAct:dmAct,actDM:actDM,objNode:retCar,

preSnapshotDM:preSnapshot_dmAct2,postSnapshotDM:preSnapshot_dmAct2, _actGrp_opName:_actGrp_opName,_nextDmAct_name:_nextDmAct_name}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_nextSysAct_coEvol.cmd

---NEXT_DMAct3_newActGrp ---Pre/Postcondition_UC ---Pre/Postcondition_DM

!create preSnapshot_dmAct3:Pre_dmAct3

!create rental:T_Rental

!set rental.name:=’rental’

!insert (preSnapshot_dmAct3,cust) into Pre_dmAct3_cust

!insert (preSnapshot_dmAct3,rental) into Pre_dmAct3_rental

---Match SysState

!set rental.value:=cust.value.rental->any(return=oclUndefined(Date)) ---Execution

!let currExec=ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let superActGrp = dmAct.actGrp->any(true)

!let _actGrp_opName=’getRental()’

!let _nextDmAct_name=’getRental’

!let matchSL=Tuple{ucAct:ucAct}

!let matchTL=Tuple{

dmAct:dmAct,actDM:actDM,superActGrp:superActGrp,objNode:cust,

preSnapshotDM:preSnapshot_dmAct3,postSnapshotDM:preSnapshot_dmAct3, _actGrp_opName:_actGrp_opName,_nextDmAct_name:_nextDmAct_name}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_nextDMAct_newActGroup_coEvol.cmd

---NEXT_ActorAct3_ConditionalBranch_coEvol ---Post_EnterCustInfo

!create postSnapshot_UpdateCarInfo:Post_UpdateCarInfo

!create mileage_Car:T_RealCls

!set mileage_Car.name:=’mileage_Car’

!insert(postSnapshot_UpdateCarInfo,mileage_Car) into Post_UpdateCarInfo_mileage_Car

---!create guard_RetrieveRentalInfo_UpdateCarInfo:

Guard_RetrieveRentalInfo_UpdateCarInfo

!insert (guard_RetrieveRentalInfo_UpdateCarInfo,cust) into Guard_RetrieveRentalInfo_UpdateCarInfo_cust

!insert (guard_RetrieveRentalInfo_UpdateCarInfo,rental) into Guard_RetrieveRentalInfo_UpdateCarInfo_rental

!insert (guard_RetrieveRentalInfo_UpdateCarInfo,id_Cust) into Guard_RetrieveRentalInfo_UpdateCarInfo_id_Cust

---Match SysState

!create mileageCarReal:RealCls

!set mileageCarReal.real:=10000

!set mileage_Car.value:=mileageCarReal

---Execution

!let currExec = ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let _actorAct_name=’supplyRentalInfo’

!let _nextDmAct_name=’updateRentalInfo’

!let matchSL = Tuple{ucAct:ucAct,actUC:actUC, preSnapshotUC:defaultSnapshot,

postSnapshotUC:postSnapshot_UpdateCarInfo,

guardSnapshotUC:guard_RetrieveRentalInfo_UpdateCarInfo, _actorAct_name:_actorAct_name}

!let matchTL = Tuple{dmAct:dmAct,actDM:actDM,

postSnapshotDM:defaultSnapshot,_nextDmAct_name:_nextDmAct_name}

!let matchCL = Tuple{currExec:currExec}

read uc2dm_nextActorAct_ConditionalBranch_coEvol.cmd

---NEXT_SysAct4 ---Pre/Postcondition_UC

!create preSnapshot_UpdateRental:Pre_UpdateRental

!create car:T_Car

!set car.name:=’car’

!insert(preSnapshot_UpdateRental,rental) into Pre_UpdateRental_rental

!insert(preSnapshot_UpdateRental,car) into Pre_UpdateRental_car

!insert(preSnapshot_UpdateRental,mileage_Car) into Pre_UpdateRental_mileage_Car

---!create postSnapshot_UpdateRental:Post_UpdateRental

!insert(postSnapshot_UpdateRental,rental) into Post_UpdateRental_rental

!insert(postSnapshot_UpdateRental,car) into Post_UpdateRental_car

!insert(postSnapshot_UpdateRental,mileage_Car) into Post_UpdateRental_mileage_Car

---Pre/Postcondition_DM

!create preSnapshot_dmAct5:Pre_dmAct5

!create today:T_DateCls

!set today.name:=’today’

!insert (preSnapshot_dmAct5,today) into Pre_dmAct5_today

---Match SysState

!create todayDateCls:DateCls

!set todayDateCls.date:=currentDate

!set today.value:=todayDateCls

---Execution

!let currExec = ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let _actGrp_opName=’updateRentalInfo()’

!let _sysAct_name=’UpdateRentalInfo’

!let _nextDmAct_name=’getCurrDay’

!let matchSL=Tuple{ucAct:ucAct,

actUC:actUC,preSnapshotUC:preSnapshot_UpdateRental,

postSnapshotUC:postSnapshot_UpdateRental,_sysAct_name:_sysAct_name}

!let matchTL=Tuple{dmAct:dmAct,actDM:actDM,objNode:retCar,

preSnapshotDM:preSnapshot_dmAct5,postSnapshotDM:preSnapshot_dmAct5, _actGrp_opName:_actGrp_opName,_nextDmAct_name:_nextDmAct_name}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_nextSysAct_coEvol.cmd

---NEXT_DMCondBranch56_NewActGrp ---Pre/Postcondition_UC ---Pre/Postcondition_DM

!create preSnapshot_dmAct6:Pre_dmAct6

!insert (preSnapshot_dmAct6,rental) into Pre_dmAct6_rental

!insert (preSnapshot_dmAct6,today) into Pre_dmAct6_today

---!create postSnapshot_dmAct6:Post_dmAct6

!insert(postSnapshot_dmAct6,rental) into Post_dmAct6_rental

!insert (postSnapshot_dmAct6,today) into Post_dmAct6_today

---!create guard_dmAct5_dmAct6:Guard_dmAct5_dmAct6

!insert(guard_dmAct5_dmAct6,rental) into Guard_dmAct5_dmAct6_rental

!insert(guard_dmAct5_dmAct6,today) into Guard_dmAct5_dmAct6_today

---Match SysState ---Execution

!let currExec = ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let superActGrp = dmAct.actGrp->any(true)

!let _dmCondEdge_guard=’else’

!let _actGrp_opName=’updateRental’

!let _nextDmAct_name=’updateReturn’

!let matchSL=Tuple{ucAct:ucAct}

!let matchTL=Tuple{dmAct:dmAct,actDM:actDM,superActGrp:superActGrp, objNode:rental,preSnapshotDM:preSnapshot_dmAct6,

postSnapshotDM:postSnapshot_dmAct6, guardSnapshotDM:guard_dmAct5_dmAct6,

_dmCondEdge_guard:_dmCondEdge_guard,_actGrp_opName:_actGrp_opName, _nextDmAct_name:_nextDmAct_name}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_nextDMCondBranch_NewActGrp_coEvol.cmd

---Update SysState

!set rental.value.return:=today.value.date

---NEXT_DMAct7 ---Pre/Postcondition_UC ---Pre/Postcondition_DM

!create preSnapshot_dmAct7:Pre_dmAct7

!insert (preSnapshot_dmAct7,rental) into Pre_dmAct7_rental

!insert (preSnapshot_dmAct7,car) into Pre_dmAct7_car

---Match SysState

!set car.value:=rental.value.car

---Execution

!let currExec = ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let actGrp = dmAct.actGrp->any(true)

!let _nextDmAct_name=’getCar’

!let matchSL=Tuple{ucAct:ucAct}

!let matchTL=Tuple{dmAct:dmAct,actDM:actDM,actGrp:actGrp,

preSnapshotDM:preSnapshot_dmAct7,postSnapshotDM:preSnapshot_dmAct7, _nextDmAct_name:_nextDmAct_name}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_nextDMAct_coEvol.cmd

---NEXT_DMAct8_newActGroup ---Pre/Postcondition_DM

!create preSnapshot_dmAct8:Pre_dmAct8

!insert (preSnapshot_dmAct8,car) into Pre_dmAct8_car

!insert (preSnapshot_dmAct8,mileage_Car) into Pre_dmAct8_mileage_Car

---!create postSnapshot_dmAct8:Post_dmAct8

!insert (postSnapshot_dmAct8,car) into Post_dmAct8_car

!insert (postSnapshot_dmAct8,mileage_Car) into Post_dmAct8_mileage_Car

---Match SysState ---Execution

!let currExec = ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let superActGrp = dmAct.actGrp->any(true).superGroup

!let _actGrp_opName=’updateCar’

!let _nextDmAct_name=’updateCar’

!let matchSL=Tuple{ucAct:ucAct}

!let matchTL=Tuple{dmAct:dmAct,actDM:actDM,superActGrp:superActGrp, objNode:car,preSnapshotDM:preSnapshot_dmAct8,

postSnapshotDM:postSnapshot_dmAct8,_actGrp_opName:_actGrp_opName, _nextDmAct_name:_nextDmAct_name}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_nextDMAct_newActGroup_coEvol.cmd

---Update SysState

!set car.value.mileage:=mileage_Car.value.real

---NEXT_ucAct ---Pre/Postcondition_UC ---Pre/Postcondition_DM ---Match SysState ---Execution

!let currExec = ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let _includedUcAct_name=’ProcessPayment’

!let _actGrp_opName = ’processPayment’

!let _nextDmAct_name=’processPayment’

!create processPayment:T_ProcessPayment

!let matchSL=Tuple{ucAct:ucAct,actUC:actUC,

preSnapshotUC:defaultSnapshot,postSnapshotUC:defaultSnapshot, _includedUcAct_name:_includedUcAct_name}

!let matchTL=Tuple{dmAct:dmAct,actDM:actDM,objNode:processPayment, preSnapshotDM:defaultSnapshot,postSnapshotDM:defaultSnapshot, _actGrp_opName:_actGrp_opName,_nextDmAct_name:_nextDmAct_name}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_nextUCAct_coEvol.cmd

---Finish UC ---Pre/Postcondition_UC ---Pre/Postcondition_DM ---Match SysState

---Execution

!let currExec = ExecControl.allInstances->any(

next=oclUndefined(ExecControl))

!let ucAct = currExec.ucAct

!let dmAct = currExec.dmAct

!let matchSL=Tuple{ucAct:ucAct,actUC:actUC, guardSnapshotUC:defaultSnapshot}

!let matchTL=Tuple{dmAct:dmAct,actDM:actDM}

!let matchCL=Tuple{currExec:currExec}

read uc2dm_finish_coEvol.cmd

Im Dokument On Integrating Triple Graph Grammars and OCL for Model-Driven Development (Seite 144-152)