| /* |
| ----------------------------------------------------------------------- |
| -- CHESS M2M plugin -- |
| -- -- |
| -- Copyright (C) 2011-2012 -- |
| -- University of Padova, ITALY -- |
| -- -- |
| -- Author: Stefano Puri stefano.puri@intecs.it -- |
| -- -- |
| -- 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-v20.html -- |
| ----------------------------------------------------------------------- |
| */ |
| |
| |
| modeltype CHESS uses "http://CHESS"; |
| modeltype UML uses "http://www.eclipse.org/uml2/3.0.0/UML"; |
| modeltype MARTE uses "http://www.eclipse.org/papyrus/MARTE/1"; |
| |
| transformation BuildMultiInstance(inout chessModel : CHESS); |
| |
| property CHESSProfile : Profile = null; |
| property model : Model = null; |
| property newMultiInstPackage : Package = null; |
| property CHGaResourcePlatformQN = "CHESS::Core::CHGaResourcePlatform"; |
| |
| |
| configuration property rootComp : String; |
| |
| property rootInstance : InstanceSpecification = null; |
| |
| main() { |
| |
| log("*** Build Multi Instances Transformation ***"); |
| model := chessModel.rootObjects()![Model]; |
| |
| CHESSProfile := model.getAppliedProfiles()->selectOne(name="CHESS").oclAsType(Profile); |
| |
| var compViewPack : Package := model.getView("ComponentView"); |
| compViewPack->map buildMultipleInstancePackage(); |
| |
| } |
| |
| /** |
| Takes the package owning the instances created by the BuildInstance trasformation and explodes |
| all the instanceSpecification and Slot deriving from Properties/Ports with mult>1 |
| */ |
| mapping UML::Package::buildMultipleInstancePackage() { |
| |
| var platforms := self.allOwnedElements()[Package]->select(isStereotyped(CHGaResourcePlatformQN))->asSequence(); |
| log("CHGaResourcesPlatforms in the model: " + platforms->size().repr()); |
| assert fatal (platforms->size()=1) with log("CHGaResourcesPlatform not found"); |
| |
| var instPackage := platforms->first(); |
| |
| var parentPackage : UML::Package := instPackage.owner.oclAsType(UML::Package); |
| |
| newMultiInstPackage := object UML::Package{}; |
| |
| newMultiInstPackage.name := instPackage.name+"_full"; |
| |
| parentPackage.packagedElement += newMultiInstPackage; |
| instPackage.map createFullInstances(); |
| |
| instPackage.map createLinks(); |
| |
| } |
| |
| mapping UML::Package::createFullInstances() { |
| |
| self.packagedElement->forEach(a){ |
| if(a.oclIsTypeOf(UML::InstanceSpecification))then{ |
| var inst := a.oclAsType(UML::InstanceSpecification); |
| if (not inst.classifier -> isEmpty()) then { |
| //this is a Component instance |
| var multiInstanceStereo := inst.getStereotypeApplications()-> |
| select(metaClassName()="MultiInstance")->asOrderedSet()->first().oclAsType(CHESS::Core::MultiInstance); |
| if (not multiInstanceStereo.oclIsInvalid()) then { |
| var i : Integer := 1; |
| while(i<=multiInstanceStereo.upperBound){ |
| inst.map cloneInst(i); |
| i:=i+1; |
| } |
| }else{ |
| inst.map cloneInst(0); |
| } |
| endif; |
| |
| }else{ |
| |
| }endif; |
| }endif; |
| } |
| } |
| |
| |
| mapping UML::Package::createLinks() { |
| |
| self.packagedElement->forEach(a){ |
| if(a.oclIsTypeOf(UML::InstanceSpecification))then{ |
| var inst := a.oclAsType(UML::InstanceSpecification); |
| if (not inst.classifier -> isEmpty()) then { |
| |
| }else{ |
| //this is an instance of Connector |
| var reqInstanceOrig : InstanceSpecification := getRequiringInstance(inst); |
| var reqPort : Port := getRequiredPort(inst); |
| var provPort : Port := getProvidedPort(inst); |
| var provInstanceOrig : InstanceSpecification := getProvidingInstance(inst); |
| var reqInstMult : Integer := 0; |
| var reqPortMult : Integer := reqPort.upperBound(); |
| var provInstMult : Integer := 0; |
| var provPortMult : Integer := provPort.upperBound(); |
| |
| var multiInstanceStereo := reqInstanceOrig.getStereotypeApplications()-> |
| select(metaClassName()="MultiInstance")->asOrderedSet()->first().oclAsType(CHESS::Core::MultiInstance); |
| if (not multiInstanceStereo.oclIsInvalid()) then { |
| reqInstMult :=multiInstanceStereo.upperBound; |
| }else{ |
| reqInstMult :=1; |
| |
| }endif; |
| multiInstanceStereo := provInstanceOrig.getStereotypeApplications()-> |
| select(metaClassName()="MultiInstance")->asOrderedSet()->first().oclAsType(CHESS::Core::MultiInstance); |
| if (not multiInstanceStereo.oclIsInvalid()) then { |
| provInstMult :=multiInstanceStereo.upperBound; |
| } |
| else{ |
| provInstMult :=1; |
| }endif; |
| |
| newMultiInstPackage.ownedElement -> forEach(newInst){ |
| var identInstStereo : CHESS::Core::IdentifInstance := newInst.getStereotypeApplications()->select(metaClassName()="IdentifInstance")-> |
| asOrderedSet()->first().oclAsType(CHESS::Core::IdentifInstance); |
| if (identInstStereo.sourceInstanceSpec = reqInstanceOrig) then { |
| |
| |
| newInst.oclAsType(UML::InstanceSpecification).map setRequired(reqPort, provPort, provInstanceOrig, provInstMult, reqInstMult, reqPortMult); |
| |
| }endif; |
| |
| }; |
| |
| }endif; |
| }endif; |
| } |
| } |
| |
| |
| mapping UML::InstanceSpecification::cloneInst (in id : Integer):UML::InstanceSpecification { |
| name := self.name; |
| classifier := self.classifier; |
| |
| newMultiInstPackage.packagedElement += result; |
| |
| self.slot->forEach(slot){ |
| var multiSlotStereo := slot.getStereotypeApplications()-> |
| select(metaClassName()="MultiSlot")->asOrderedSet()->first().oclAsType(CHESS::Core::MultiSlot); |
| if (not multiSlotStereo.oclIsInvalid()) then { |
| var i : Integer := 1; |
| while(i<=multiSlotStereo.upperBound){ |
| slot.map cloneSlot(i, result); |
| i:=i+1; |
| } |
| }else{ |
| slot.map cloneSlot(0, result); |
| }endif; |
| |
| }; |
| |
| var identifInstance := result.applyStereotype(getCHESSStereotype("IdentifInstance")).oclAsType(CHESS::Core::IdentifInstance); |
| identifInstance.id := id; |
| identifInstance.sourceInstanceSpec :=self; |
| |
| |
| } |
| |
| mapping UML::Slot::cloneSlot (in id : Integer, inout inst : InstanceSpecification):UML::Slot { |
| definingFeature := self.definingFeature; |
| inst.slot += result; |
| if (id > 0) then{ |
| var identifSlot := result.applyStereotype(getCHESSStereotype("IdentifSlot")).oclAsType(CHESS::Core::IdentifSlot); |
| identifSlot.id := id; |
| }endif; |
| |
| var chRtSlotStereo : CHESS::RTComponentModel::CHRtPortSlot := self.getStereotypeApplications()-> |
| select(metaClassName()="CHRtPortSlot")->asOrderedSet()->first().oclAsType(CHESS::RTComponentModel::CHRtPortSlot); |
| if (not chRtSlotStereo.oclIsInvalid()) then { |
| var chrtslot := result.applyStereotype(getCHESSStereotype("CHRtPortSlot")).oclAsType(CHESS::RTComponentModel::CHRtPortSlot); |
| chrtslot.cH_RtSpecification := chRtSlotStereo.cH_RtSpecification; |
| }endif; |
| |
| |
| |
| } |
| |
| |
| query getRequiringInstance(connInst : UML::InstanceSpecification) : UML::InstanceSpecification { |
| connInst.slot->forEach(sl){ |
| if (sl.oclAsType(UML::Slot).definingFeature.oclIsKindOf(UML::Port)) then{ |
| var port : UML::Port := sl.oclAsType(UML::Slot).definingFeature.oclAsType(UML::Port); |
| |
| port.getStereotypeApplications()->select(metaClassName()="ClientServerPort")->forEach(csp){ |
| var p := csp.oclAsType(MARTE::GCM::ClientServerPort); |
| if(p.kind = MARTE::GCM::ClientServerKind::required)then{ |
| return sl.value->select(name="partWithPort")->asOrderedSet()->first().oclAsType(UML::InstanceValue).instance; |
| }endif; |
| } |
| |
| }endif; |
| }; |
| return null; |
| } |
| |
| query getRequiredPort(connInst : UML::InstanceSpecification) : UML::Port { |
| connInst.slot->forEach(sl){ |
| if (sl.oclAsType(UML::Slot).definingFeature.oclIsKindOf(UML::Port)) then{ |
| var port : UML::Port := sl.oclAsType(UML::Slot).definingFeature.oclAsType(UML::Port); |
| |
| port.getStereotypeApplications()->select(metaClassName()="ClientServerPort")->forEach(csp){ |
| var p := csp.oclAsType(MARTE::GCM::ClientServerPort); |
| if(p.kind = MARTE::GCM::ClientServerKind::required)then{ |
| return sl.definingFeature.oclAsType(UML::Port); |
| }endif; |
| } |
| |
| }endif; |
| }; |
| return null; |
| } |
| |
| query getProvidingInstance(connInst : UML::InstanceSpecification) : UML::InstanceSpecification { |
| connInst.slot->forEach(sl){ |
| if (sl.oclAsType(UML::Slot).definingFeature.oclIsKindOf(UML::Port)) then{ |
| var port : UML::Port := sl.oclAsType(UML::Slot).definingFeature.oclAsType(UML::Port); |
| |
| port.getStereotypeApplications()->select(metaClassName()="ClientServerPort")->forEach(csp){ |
| var p := csp.oclAsType(MARTE::GCM::ClientServerPort); |
| if(p.kind = MARTE::GCM::ClientServerKind::provided)then{ |
| return sl.value->select(name="partWithPort")->asOrderedSet()->first().oclAsType(UML::InstanceValue).instance; |
| }endif; |
| } |
| |
| }endif; |
| }; |
| return null; |
| } |
| |
| query getProvidedPort(connInst : UML::InstanceSpecification) : UML::Port { |
| connInst.slot->forEach(sl){ |
| if (sl.oclAsType(UML::Slot).definingFeature.oclIsKindOf(UML::Port)) then{ |
| var port : UML::Port := sl.oclAsType(UML::Slot).definingFeature.oclAsType(UML::Port); |
| |
| port.getStereotypeApplications()->select(metaClassName()="ClientServerPort")->forEach(csp){ |
| var p := csp.oclAsType(MARTE::GCM::ClientServerPort); |
| if(p.kind = MARTE::GCM::ClientServerKind::provided)then{ |
| return sl.definingFeature.oclAsType(UML::Port); |
| }endif; |
| } |
| |
| }endif; |
| }; |
| return null; |
| } |
| |
| |
| |
| |
| |
| //set links between required ports and provided ports |
| mapping UML::InstanceSpecification::setRequired(in reqPort : UML::Port, in provPort : UML::Port, |
| in destInst : UML::InstanceSpecification, in provCompMult: Integer, in reqCompMult: Integer, in reqPortMult: Integer){ |
| //var chessComp := sm.objectsOfType(UML::Component)->select(name = self.name)->asOrderedSet()->first(); |
| var instId : Integer :=0; |
| var identifInstStereo : CHESS::Core::IdentifInstance := self.getStereotypeApplications()-> |
| select(metaClassName()="IdentifInstance")->asOrderedSet()->first().oclAsType(CHESS::Core::IdentifInstance); |
| instId := identifInstStereo.id; |
| |
| self.slot->select(definingFeature.oclIsKindOf(UML::Port))->forEach(slot){ |
| var p : UML::Port := slot.definingFeature.oclAsType(UML::Port); |
| if (p=reqPort) then { |
| var reqPortId : Integer := 0; |
| var identifSlotStereo : CHESS::Core::IdentifSlot := slot.getStereotypeApplications()-> |
| select(metaClassName()="IdentifSlot")->asOrderedSet()->first().oclAsType(CHESS::Core::IdentifSlot); |
| reqPortId := identifSlotStereo.id; |
| |
| //create new InstanceSpecification for connector |
| var connInst : UML::InstanceSpecification := new InstanceSpecification (); |
| //set Slot for requiredPort |
| var reqSlot : UML::Slot := new Slot(); |
| newMultiInstPackage.packagedElement += connInst; |
| connInst.slot += reqSlot; |
| reqSlot.definingFeature := reqPort; |
| var instValue : UML::InstanceValue := new InstanceValue(); |
| reqSlot.value += instValue; |
| instValue.instance := self; |
| var identifSlot := reqSlot.applyStereotype(getCHESSStereotype("IdentifSlot")).oclAsType(CHESS::Core::IdentifSlot); |
| identifSlot.id := reqPortId; |
| |
| //now set Slot for provided port |
| |
| var portID := 0; //0 is the value in case of provPort.upperBound()=1 |
| var destCompID := 0; //0 is the value in case of provCompMult=1 |
| //if reqP.mult = comp.mult*provP.mult then same as for setEmptyLinks() |
| if(p.upperBound()=provPort.upperBound()*provCompMult)then{ |
| |
| if (provPort.upperBound()>1)then{ |
| if(reqPortId.mod(provPort.upperBound())<>0)then{ |
| portID := reqPortId.mod(provPort.upperBound()); |
| }else{ |
| portID :=provPort.upperBound(); |
| }endif; |
| }endif; |
| |
| if (provCompMult > 1) then { |
| if(reqPortId.mod(provPort.upperBound())<>0)then{ |
| destCompID := (reqPortId/provPort.upperBound()).floor()+1; |
| }else{ |
| destCompID := (reqPortId/provPort.upperBound()).floor(); |
| }endif; |
| }endif; |
| }else{ |
| //case reqP.mult=1, comp.mult=provP.mult*destComp.mult |
| if(p.upperBound()=1 and reqCompMult=provPort.upperBound()*provCompMult)then{ |
| |
| if (provPort.upperBound()>1)then{ |
| |
| if(instId.mod(provPort.upperBound())<>0)then{ |
| portID := instId.mod(provPort.upperBound()); |
| }else{ |
| portID := provPort.upperBound(); |
| }endif; |
| }endif; |
| if (provCompMult > 1) then { |
| if(instId.mod(provPort.upperBound())<>0)then{ |
| destCompID := (instId/provPort.upperBound()).floor()+1; |
| }else{ |
| destCompID := (instId/provPort.upperBound()).floor(); |
| }endif; |
| }endif; |
| }else{ |
| //case reqP.mult=provP.mult |
| if(p.upperBound() = provPort.upperBound())then{ |
| |
| if (provPort.upperBound()>1)then{ |
| if(instId.mod(provPort.upperBound())<>0)then{ |
| portID := instId.mod(provPort.upperBound()); |
| }else{ |
| portID := provPort.upperBound(); |
| }endif; |
| }endif; |
| if (provCompMult >1) then { |
| if(instId.mod(provPort.upperBound())<>0)then{ |
| destCompID := (instId/provPort.upperBound()).floor()+1; |
| }else{ |
| destCompID := (instId/provPort.upperBound()).floor(); |
| }endif; |
| }endif; |
| }else{ |
| //case reqP.mult*comp.mult=provP.mult (compDest.mult = 1) |
| if(p.upperBound()*reqCompMult = provPort.upperBound())then{ |
| if (provPort.upperBound()>1)then{ |
| portID := p.upperBound()*reqCompMult; |
| }endif; |
| if (provCompMult > 1) then { |
| destCompID := 1; |
| }endif; |
| }else{ |
| //case reqP.mult*comp.mult=destComp.mult (provP.mult = 1) ---> (self.relId*reqP.mult)-(reqP.mult-reqP.relId) |
| if(p.upperBound()*reqCompMult=provCompMult)then{ |
| if (provPort.upperBound()>1)then{ |
| portID := 1; |
| }endif; |
| if (provCompMult > 1) then { |
| destCompID := (instId*p.upperBound())-(p.upperBound()-reqPortId); |
| }endif; |
| log("MISSING CASE"+" comp:"+instId.toString()+" reqP:"+reqPortId.toString()+" destC:"+destCompID.toString()); |
| }endif; |
| }endif; |
| }endif; |
| }endif; |
| }endif; |
| |
| var provIdentifInstance : UML::InstanceSpecification := getIdentifInstance(destCompID, destInst); |
| |
| //set Slot for providedPort |
| var provSlot : UML::Slot := new Slot(); |
| connInst.slot += provSlot; |
| provSlot.definingFeature := provPort; |
| instValue := new InstanceValue(); |
| provSlot.value += instValue; |
| instValue.instance := provIdentifInstance; |
| identifSlot := provSlot.applyStereotype(getCHESSStereotype("IdentifSlot")).oclAsType(CHESS::Core::IdentifSlot); |
| identifSlot.id := portID; |
| |
| }endif; |
| |
| }; |
| } |
| |
| query getIdentifInstance(in id : Integer, in origInstance : UML::InstanceSpecification):UML::InstanceSpecification{ |
| newMultiInstPackage.ownedElement->forEach(elem){ |
| var identifInstStereo : CHESS::Core::IdentifInstance := elem.getStereotypeApplications()-> |
| select(metaClassName()="IdentifInstance")->asOrderedSet()->first().oclAsType(CHESS::Core::IdentifInstance); |
| if (not identifInstStereo.oclIsInvalid()) then{ |
| if (identifInstStereo.id = id and identifInstStereo.sourceInstanceSpec = origInstance) then { |
| return elem.oclAsType(UML::InstanceSpecification); |
| }endif; |
| }endif; |
| }; |
| return null; |
| } |
| |
| |
| |
| //find the provided port for the required port in input among the connectors in input |
| query Set(UML::Connector)::findOtherEndReq(in pin : String, in cin : String) : UML::ConnectorEnd{ |
| self->forEach(c){ |
| var en := c._end->select(role.name = pin and partWithPort.name=cin)->asOrderedSet()->first(); |
| if((not en.oclIsInvalid()))then{ |
| var target := c._end->select(partWithPort.name <> cin and role.oclAsType(UML::Port).getStereotypeApplications()-> |
| select(metaClassName()="ClientServerPort")->asOrderedSet()->first().oclAsType(MARTE::GCM::ClientServerPort).kind=MARTE::GCM::ClientServerKind::provided)-> |
| asOrderedSet()->first(); |
| return target; |
| }endif; |
| }; |
| return null; |
| } |
| |
| |
| query getCHESSStereotype(stereoName : String) : Stereotype { |
| return CHESSProfile.allOwnedElements()[Stereotype]->selectOne(name=stereoName); |
| } |
| |
| query getCHRtSpecification(port : UML::Port, partWithPort : UML::Property, setComm : Set(UML::Comment)) : chessmlprofile::RTComponentModel::CHRtSpecification { |
| |
| setComm->forEach(comm){ |
| var c := comm.getStereotypeApplications()-> |
| select(metaClassName()="CHRtSpecification")->asOrderedSet()->first().oclAsType(chessmlprofile::RTComponentModel::CHRtSpecification); |
| |
| if (c != null)then{ |
| if (partWithPort != null) then{ |
| |
| if (c.partWithPort = partWithPort and c.base_Comment.annotatedElement->includes(port)) then{ |
| return c; |
| }endif; |
| }else{ |
| if (c.base_Comment.annotatedElement->includes(port)) then{ |
| return c; |
| }endif; |
| |
| }endif; |
| }endif; |
| }; |
| return null; |
| } |
| |
| query getRequiredPort(conn : UML::Connector) : UML::Port { |
| conn._end->forEach(conEnd){ |
| var martePort := conEnd.role.oclAsType(UML::Port).getStereotypeApplications()-> |
| select(metaClassName()="ClientServerPort")->asOrderedSet()->first().oclAsType(MARTE::GCM::ClientServerPort); |
| if(conEnd.partWithPort <> null and martePort.kind=MARTE::GCM::ClientServerKind::required)then{ |
| return conEnd.role.oclAsType(UML::Port); |
| }endif; |
| }; |
| return null; |
| } |
| |
| query getRequiredProperty(conn : UML::Connector) : UML::Property { |
| conn._end->forEach(conEnd){ |
| var martePort := conEnd.role.oclAsType(UML::Port).getStereotypeApplications()-> |
| select(metaClassName()="ClientServerPort")->asOrderedSet()->first().oclAsType(MARTE::GCM::ClientServerPort); |
| if(conEnd.partWithPort <> null and martePort.kind=MARTE::GCM::ClientServerKind::required)then{ |
| return conEnd.partWithPort.oclAsType(UML::Property); |
| }endif; |
| }; |
| return null; |
| } |
| |
| query getProvidedProperty(conn : UML::Connector) : UML::Property { |
| conn._end->forEach(conEnd){ |
| var martePort := conEnd.role.oclAsType(UML::Port).getStereotypeApplications()-> |
| select(metaClassName()="ClientServerPort")->asOrderedSet()->first().oclAsType(MARTE::GCM::ClientServerPort); |
| if(conEnd.partWithPort <> null and martePort.kind=MARTE::GCM::ClientServerKind::provided)then{ |
| return conEnd.partWithPort.oclAsType(UML::Property); |
| }endif; |
| }; |
| return null; |
| } |
| |
| query Model::getView(viewName : String) : Package { |
| var seq := self.packagedElement[Package]-> union(self.packagedElement[Package].packagedElement[Package]); |
| return seq -> selectOne(isStereotyped("CHESS::Core::CHESSViews::" + viewName)); |
| } |
| |
| query Element::isStereotyped(stereoName : String) : Boolean { |
| return self.getAppliedStereotype(stereoName) <> null |
| } |
