plugins/contracts/org.polarsys.chess.contracts.transformations/src/org/polarsys/chess/contracts/transformations/main/generate.mtl - chess/chess - Git at Google

 [comment encoding = UTF-8 /]
 [comment
 /*****************************************************************************
  * Copyright (c) 2013 Intecs SpA
  * 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:
  * Nicholas Pacini nicholas.pacini@intecs.it
  * Stefano Puri stefano.puri@intecs.it
  * Laura Baracchi  laura.baracchi@intecs.it
  * Irfan Sljivo irfan.sljivo@mdh.se
  * Initial API and implementation and/or initial documentation
  *
  *****************************************************************************/
 /]

 [module generate('http://www.eclipse.org/uml2/5.0.0/UML')]
 [import org::polarsys::chess::contracts::transformations::main::generateImplementation /]

 [template public mainTemplate(model : Model, sysQN : String , sysName : String, filename : String, checkWeakContracts: String){
 	SystemQN : String = 'CHESSContract::System';
 	SubSystemQN : String = 'CHESSContract::SubSystem';
 	SystemViewQN : String = 'CHESS::Core::CHESSViews::SystemView';
 	CompViewQN : String = 'CHESS::Core::CHESSViews::ComponentView';
 	DeplViewQN : String = 'CHESS::Core::CHESSViews::DeploymentView';
 	CompImplQN : String = 'CHESS::ComponentModel::ComponentImplementation';
 	PlatformQN : String = 'CHESSContract::Platform';
 	BlockQN : String = 'SysML::Blocks::Block';
 	SRACompQN : String = 'CHESSContract::SRAComponent';

 }]
 	[comment @main/]
 [file (filename.concat('_').concat(sysName).concat('.oss'), false, 'UTF-8')]
 	[let componentView : Package = model.nestedPackage->any(p : Package | p.getAppliedStereotype(CompViewQN)->notEmpty())]
 	[let systemView : Package = model.nestedPackage->any(p : Package | p.getAppliedStereotype(SystemViewQN)->notEmpty())]
 	[let deploymentView : Package =  model.nestedPackage->any(p : Package | p.getAppliedStereotype(DeplViewQN)->notEmpty())]
 	[let allBlocks : Set(Class) = getAllBlocks(componentView.allOwnedElements()->filter(Class)->union(systemView.allOwnedElements()->filter(Class)), BlockQN, SubSystemQN, SystemQN)]
 	[let allComps : Set(Component) = getAllComponents(deploymentView.allOwnedElements()->filter(Component), componentView.allOwnedElements()->filter(Component), CompImplQN, SRACompQN)]
 	[let generated : Set(String) = getEmptyStringSet()]
 	[let system : Class = getSystem(allBlocks, sysQN)]
 [generateComponent(system, true, allBlocks->union(allComps), generated,checkWeakContracts.equalsIgnoreCase('true'))/]
 	[/let]
 	[/let]
 	[/let]
 	[/let]
 	[/let]
 	[/let]
 	[/let]
 [/file]

 [for (sm : StateMachine | model.allOwnedElements()->filter(StateMachine))]
 	[if (sm.owner.getAppliedStereotype(BlockQN)->notEmpty() or sm.owner.getAppliedStereotype(CompImplQN)->notEmpty())]
 	[if(sm.owner.oclIsTypeOf(Class) or sm.owner.oclIsTypeOf(Component))]
 [generateImplementation(sm.owner.oclAsType(Class))/]
 	[/if]
 	[/if]
 [/for]


 [/template]

 [template public generateComponent(block : Class, isSystem : Boolean, allBlocks : Set(Class), generated : Set(String), checkWeak : Boolean){
 	SystemQN : String = 'CHESSContract::System';
 	FlowPortQN : String = 'SysML::PortAndFlows::FlowPort';
 	FlowPortMarteQN : String = 'MARTE::MARTE_DesignModel::GCM::FlowPort';
 	ContractPropQN : String = 'CHESSContract::ContractProperty';
 	DelegConstrQN : String = 'CHESSContract::DelegationConstraint';
 	CSPortQN : String = 'MARTE::MARTE_DesignModel::GCM::ClientServerPort';

 }]
 	[addToGenerated(block.name, generated)/]
 	[if (isSystem)]
 	COMPONENT system
 	[else]
 	COMPONENT [block.name/]
 	[/if]

 	INTERFACE

 	[let props : OrderedSet(Property) = block.ownedAttribute->filter(Property)]
 	[for (prop : Property | props)]
 	[if (prop.oclIsTypeOf(Port))]
 	[let port : Port = prop.oclAsType(Port)]
 		[if (port.getAppliedStereotype(FlowPortQN)->notEmpty())]
 		[let direction : OclAny = port.getValue(port.getAppliedStereotype(FlowPortQN), 'direction')]
 	[getDirection(direction.toString())/]PORT [port.name/] : [if (not port.type.oclIsUndefined())][getType(port.type)/];[/if]
 		[/let]
 		[elseif (port.getAppliedStereotype(FlowPortMarteQN)->notEmpty())]
 		[let direction : OclAny = port.getValue(port.getAppliedStereotype(FlowPortMarteQN), 'direction')]
 	[getDirection(direction.toString())/]PORT [port.name/] : [if (not port.type.oclIsUndefined())][getType(port.type)/];[/if]
 		[/let]
 		[/if]
 	[comment operations /]
 		[if (port.getAppliedStereotype(CSPortQN)->notEmpty())]
 		[let proreq : OclAny = port.getValue(port.getAppliedStereotype(CSPortQN), 'kind')]
 		[let interface : Interface = getInterface(port)]
 		[if (interface <> oclIsUndefined())]
 		[for (op : Operation | interface.getOperations())]
 	[proreq.toString().toUpper()/] OPERATION PORT [getOperationName(op, port)/] ([getParamList(op)/]) : [getReturn(op)/];
 		[/for]
 		[/if]
 		[/let]
 		[/let]
 		[/if]
 	[/let]
 	[elseif (not prop.type.oclIsUndefined() and not prop.type.oclIsTypeOf(Class) and not prop.type.oclIsTypeOf(Component))]
 	PARAMETER [prop.name/] : [if (not prop.type.oclIsUndefined())][getType(prop.type)/];[/if]
 	[/if]
 	[/for]
 	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property | p.getAppliedStereotype(ContractPropQN)->notEmpty())]
 	[for (contrProp : Property | contrProps)]
 	[let contract : Class = contrProp.type.oclAsType(Class)]

 	CONTRACT [contrProp.name/]
 	assume:
 		[getAssume(contract)/];
 	guarantee:
 		[getGuarantee(contract)/];
 	[/let]
 	[/for]
 	[/let]
 	[if checkWeak]

 	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property | p.getAppliedStereotype(ContractPropQN)->notEmpty() and isWeakContract(p))]
 	[if (contrProps->size() > 0)]
 	CONTRACT [block.name/]_allWeak
 	assume:
 		TRUE;
 	guarantee:
 	[for (contrProp : Property | contrProps) separator (' and ')][let contract : Class = contrProp.type.oclAsType(Class)][if not isAssumptionTrue(contract)](([getAssume(contract)/]) implies [/if]([getGuarantee(contract)/])[if not isAssumptionTrue(contract)])[/if][/let][/for];
 	[/if]
 	[/let]
 	[/if]

 	REFINEMENT

 	[let parts : OrderedSet(Property) = block.ownedAttribute->filter(Property)]
 	[for (part : Property | parts)]
 		[if (isPart(part))]
 	SUB	[part.name/] : [part.type.name/];
 		[/if]
 	[/for]

 	[let connections : Set(Connector) = block.ownedConnector]
 	[for (conn : Connector | connections)]
 	[if (checkConnectedPorts(conn))]
 	[comment data ports /]
 	[if (checkRules(conn))]
 	[if (conn.end->first().partWithPort.oclIsUndefined())]
 	CONNECTION [conn.end->first().role.name/] := [conn.end->last().partWithPort.name/].[conn.end->last().role.name/];
 	[elseif (conn.end->last().partWithPort.oclIsUndefined())]
 	CONNECTION [conn.end->first().partWithPort.name/].[conn.end->first().role.name/] := [conn.end->last().role.name/];
 	[else]
 	CONNECTION [conn.end->first().partWithPort.name/].[conn.end->first().role.name/] := [conn.end->last().partWithPort.name/].[conn.end->last().role.name/];
 	[/if]
 	[else]
 	[if (conn.end->last().partWithPort.oclIsUndefined())]
 	CONNECTION [conn.end->last().role.name/] := [conn.end->first().partWithPort.name/].[conn.end->first().role.name/];
 	[elseif (conn.end->first().partWithPort.oclIsUndefined())]
 	CONNECTION [conn.end->last().partWithPort.name/].[conn.end->last().role.name/] := [conn.end->first().role.name/];
 	[else]
 	CONNECTION [conn.end->last().partWithPort.name/].[conn.end->last().role.name/] := [conn.end->first().partWithPort.name/].[conn.end->first().role.name/];
 	[/if]
 	[/if]
 	[else]
 	[comment operation ports /]
 	[if (checkOperationPorts(conn))]
 	[getOperationConnections(conn)/]
 	[/if]
 	[/if]
 	[/for]
 	[/let]

 	[let rules : Set(Constraint) = block.ownedRule->select(c : Constraint | c.getAppliedStereotype(DelegConstrQN)->notEmpty())]
   	[for (rule : Constraint | rules)]
   	[if ((rule.specification.oclIsKindOf(OpaqueExpression) and rule.specification.oclAsType(OpaqueExpression).language.contains('OCRA')->notEmpty()))]
   	[let  index : Integer = rule.specification.oclAsType(OpaqueExpression).language->indexOf('OCRA')]
   	[let spec : String = rule.specification.oclAsType(OpaqueExpression)._body->at(index)]
   	CONNECTION [spec/][if not(spec.endsWith(';'))];[/if]
   	[/let]
   	[/let]
   	[/if]
   	[/for]
   	[/let]

 	[if checkWeak]
 	[comment if the checkAllWeakContracts is true, then generate refinedby for all strong, and if there are any weak, then generate only one refinedby for allweak contract /]
 	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property | p.getAppliedStereotype(ContractPropQN)->notEmpty() and not isWeakContract(p))]
 	[for (contrProp : Property | contrProps)]
 	[if (isRefined(contrProp))]
 	[let contract : Class = contrProp.type.oclAsType(Class)]
 	CONTRACT [contrProp.name/] REFINEDBY [getRefinedByStrongWeak(contrProp,parts)/]
 	[/let]
 	[/if]
 	[/for]
 	[/let]

 	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property | p.getAppliedStereotype(ContractPropQN)->notEmpty() and isWeakContract(p))]
 	[let refinedByAllWeak: String = getRefinedByAllWeak(contrProps,parts)]
 	[if (contrProps->size() > 0 and not refinedByAllWeak.startsWith(';'))]
 	CONTRACT [block.name/]_allWeak REFINEDBY [refinedByAllWeak/]

 	[/if]
 	[/let]
 	[/let]
 	[else]
 	[comment if checkAllWeakContracts is false, then generate refinedby for all selected contracts /]
 	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property | p.getAppliedStereotype(ContractPropQN)->notEmpty())]
 	[for (contrProp : Property | contrProps)]
 	[if (isRefined(contrProp))]
 	[let contract : Class = contrProp.type.oclAsType(Class)]
 	CONTRACT [contrProp.name/] REFINEDBY [getRefinedBy(contrProp)/]
 	[/let]
 	[/if]
 	[/for]
 	[/let]
 	[/if]

 	[if (checkWeak)]
 	[for (part : Property | parts)]
 		[if (isPart(part))]
 	[let nextblock : Class = allBlocks->any(c : Class | part.type = c)]
 	[let contrProps : OrderedSet(Property) = nextblock.ownedAttribute->select(p : Property | p.getAppliedStereotype(ContractPropQN)->notEmpty())]
 	[for (contrProp : Property | contrProps)]
 	[let contract : Class = contrProp.type.oclAsType(Class)]
 		[if (isWeakContract(contrProp) and not isAssumptionTrue(contract))]
 	CONSISTENCY NAME [nextblock.name/]_[contrProp.name/]_consistency := [part.name/].[contrProp.name/].ASSUMPTION;
 		[/if]
 	[/let]
 	[/for]
 	[/let]
 	[/let]
 		[/if]
 	[/for]
 	[/if]

 	[for (part : Property | parts)]
 	[if (isPart(part) and not isAlreadyGenerated(part.type.name, generated))]
 		[let newblock : Class = allBlocks->any(c : Class | part.type = c)]
 	[generateComponent(newblock, false, allBlocks, generated,checkWeak)/]
 		[/let]
 	[/if]
 	[/for]
 	[/let]
 	[/let]

 [/template]

 [query public getInterface(port : Port) : Interface =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getInterface(org.eclipse.uml2.uml.Port)', Sequence{port}) /]

 [query public getReturn(op : Operation) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getReturn(org.eclipse.uml2.uml.Operation)', Sequence{op}) /]

 [query public getParamList(op : Operation) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getParamList(org.eclipse.uml2.uml.Operation)', Sequence{op}) /]

 [query public getOperationName(op : Operation, port : Port) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getOperationName(org.eclipse.uml2.uml.Operation, org.eclipse.uml2.uml.Port)', Sequence{op, port}) /]

 [query public getSystem(classes : Set(Class), qname : String) : Class =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getSystem(java.util.Set, java.lang.String)', Sequence{classes, qname}) /]

 [query public getAllBlocks(classes : Set(Class), blockQN : String, SubSystemQN : String, SystemQN : String) : Set(Class) =
 classes->select(c : Class | c.getAppliedStereotype(blockQN)->notEmpty() or c.getAppliedStereotype(SubSystemQN)->notEmpty() or c.getAppliedStereotype(SystemQN)->notEmpty()) /]

 [query public getAllComponents(hwcomps : Set(Component), comps : Set(Component), CompImplQN : String, PlatformQN : String) : Set(Component) =
 comps->select(c : Component | c.getAppliedStereotype(CompImplQN)->notEmpty() or c.getAppliedStereotype(PlatformQN)->notEmpty())->union(hwcomps) /]

 [query public getDirection(dir : String) : String =
 if self='in' then 'INPUT ' else if self = 'out' then 'OUTPUT ' else '' endif endif /]

 [query public isPart(prop : Property) : Boolean =
 if self.type.oclIsTypeOf(Component) or self.type.getAppliedStereotype('CHESS::ComponentModel::ComponentImplementation')->notEmpty() or self.type.getAppliedStereotype('SysML::Blocks::Block')->notEmpty() or self.type.getAppliedStereotype('CHESSContract::SubSystem')->notEmpty() then true else false endif /]

 [query public isDelegation(conn : Connector) : Boolean =
 if (conn.end->first().partWithPort.oclIsUndefined()) xor (conn.end->last().partWithPort.oclIsUndefined())
 then true else false endif /]

 [query public firstIsSub(conn : Connector) : Boolean =
 if (conn.end->first().partWithPort.oclIsUndefined()) then false else true endif/]

 [query public getNewBlocks(parts : Set(Property)) : Set(String) =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getNewBlocks(java.util.Set)', Sequence{parts}) /]

 [query public getEmptyStringSet(traceCtx : OclAny) : Set(String) =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getEmptyStringSet()', Sequence{}) /]

 [query public addToGenerated(name : String, generated : Set(String)) : OclAny =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'addToGenerated(java.lang.String, java.util.Set)', Sequence{name, generated}) /]

 [query public isAlreadyGenerated(name : String, generated : Set(String)) : Boolean =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isAlreadyGenerated(java.lang.String, java.util.Set)', Sequence{name, generated}) /]

 [query public getAssume(contract: Class) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getAssume(org.eclipse.uml2.uml.Class)', Sequence{contract}) /]

 [query public getGuarantee(contract: Class) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getGuarantee(org.eclipse.uml2.uml.Class)', Sequence{contract}) /]

 [query public isRefined(prop : Property) : Boolean =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isRefined(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

 [query public getRefinedBy(prop : Property) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getRefinedBy(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

 [query public getRefinedByStrongWeak(prop : Property, parts : Set (Property)) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getRefinedByStrongWeak(org.eclipse.uml2.uml.Property,java.util.Set)', Sequence{prop,parts}) /]

 [query public getRefinedByAllWeak(props : Set (Property), parts : Set (Property)) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getRefinedByAllWeak(java.util.Set,java.util.Set)', Sequence{props,parts}) /]

 [query public getContractType(prop : Property) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getContractType(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

 [query public isWeakContract(prop : Property) : Boolean =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isWeakContract(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

 [query public isAssumptionTrue(contract: Class) : Boolean =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isAssumptionTrue(org.eclipse.uml2.uml.Class)', Sequence{contract}) /]

 [query public checkRules(conn : Connector) : Boolean =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'checkRules(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

 [query public checkConnectedPorts(conn : Connector) : Boolean =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'checkConnectedPorts(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

 [query public checkOperationPorts(conn : Connector) : Boolean =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'checkOperationPorts(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

 [query public getOperationConnections(conn : Connector) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getOperationConnections(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

 [query public getType(type : Type) : String =
 invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getType(org.eclipse.uml2.uml.Type)', Sequence{type}) /]
	[comment encoding = UTF-8 /]
	[comment
	/*****************************************************************************
	* Copyright (c) 2013 Intecs SpA
	* 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:
	* Nicholas Pacini nicholas.pacini@intecs.it
	* Stefano Puri stefano.puri@intecs.it
	* Laura Baracchi laura.baracchi@intecs.it
	* Irfan Sljivo irfan.sljivo@mdh.se
	* Initial API and implementation and/or initial documentation
	*
	*****************************************************************************/
	/]

	[module generate('http://www.eclipse.org/uml2/5.0.0/UML')]
	[import org::polarsys::chess::contracts::transformations::main::generateImplementation /]

	[template public mainTemplate(model : Model, sysQN : String , sysName : String, filename : String, checkWeakContracts: String){
	SystemQN : String = 'CHESSContract::System';
	SubSystemQN : String = 'CHESSContract::SubSystem';
	SystemViewQN : String = 'CHESS::Core::CHESSViews::SystemView';
	CompViewQN : String = 'CHESS::Core::CHESSViews::ComponentView';
	DeplViewQN : String = 'CHESS::Core::CHESSViews::DeploymentView';
	CompImplQN : String = 'CHESS::ComponentModel::ComponentImplementation';
	PlatformQN : String = 'CHESSContract::Platform';
	BlockQN : String = 'SysML::Blocks::Block';
	SRACompQN : String = 'CHESSContract::SRAComponent';

	}]
	[comment @main/]
	[file (filename.concat('_').concat(sysName).concat('.oss'), false, 'UTF-8')]
	[let componentView : Package = model.nestedPackage->any(p : Package \| p.getAppliedStereotype(CompViewQN)->notEmpty())]
	[let systemView : Package = model.nestedPackage->any(p : Package \| p.getAppliedStereotype(SystemViewQN)->notEmpty())]
	[let deploymentView : Package = model.nestedPackage->any(p : Package \| p.getAppliedStereotype(DeplViewQN)->notEmpty())]
	[let allBlocks : Set(Class) = getAllBlocks(componentView.allOwnedElements()->filter(Class)->union(systemView.allOwnedElements()->filter(Class)), BlockQN, SubSystemQN, SystemQN)]
	[let allComps : Set(Component) = getAllComponents(deploymentView.allOwnedElements()->filter(Component), componentView.allOwnedElements()->filter(Component), CompImplQN, SRACompQN)]
	[let generated : Set(String) = getEmptyStringSet()]
	[let system : Class = getSystem(allBlocks, sysQN)]
	[generateComponent(system, true, allBlocks->union(allComps), generated,checkWeakContracts.equalsIgnoreCase('true'))/]
	[/let]
	[/let]
	[/let]
	[/let]
	[/let]
	[/let]
	[/let]
	[/file]

	[for (sm : StateMachine \| model.allOwnedElements()->filter(StateMachine))]
	[if (sm.owner.getAppliedStereotype(BlockQN)->notEmpty() or sm.owner.getAppliedStereotype(CompImplQN)->notEmpty())]
	[if(sm.owner.oclIsTypeOf(Class) or sm.owner.oclIsTypeOf(Component))]
	[generateImplementation(sm.owner.oclAsType(Class))/]
	[/if]
	[/if]
	[/for]


	[/template]

	[template public generateComponent(block : Class, isSystem : Boolean, allBlocks : Set(Class), generated : Set(String), checkWeak : Boolean){
	SystemQN : String = 'CHESSContract::System';
	FlowPortQN : String = 'SysML::PortAndFlows::FlowPort';
	FlowPortMarteQN : String = 'MARTE::MARTE_DesignModel::GCM::FlowPort';
	ContractPropQN : String = 'CHESSContract::ContractProperty';
	DelegConstrQN : String = 'CHESSContract::DelegationConstraint';
	CSPortQN : String = 'MARTE::MARTE_DesignModel::GCM::ClientServerPort';

	}]
	[addToGenerated(block.name, generated)/]
	[if (isSystem)]
	COMPONENT system
	[else]
	COMPONENT [block.name/]
	[/if]

	INTERFACE

	[let props : OrderedSet(Property) = block.ownedAttribute->filter(Property)]
	[for (prop : Property \| props)]
	[if (prop.oclIsTypeOf(Port))]
	[let port : Port = prop.oclAsType(Port)]
	[if (port.getAppliedStereotype(FlowPortQN)->notEmpty())]
	[let direction : OclAny = port.getValue(port.getAppliedStereotype(FlowPortQN), 'direction')]
	[getDirection(direction.toString())/]PORT [port.name/] : [if (not port.type.oclIsUndefined())][getType(port.type)/];[/if]
	[/let]
	[elseif (port.getAppliedStereotype(FlowPortMarteQN)->notEmpty())]
	[let direction : OclAny = port.getValue(port.getAppliedStereotype(FlowPortMarteQN), 'direction')]
	[getDirection(direction.toString())/]PORT [port.name/] : [if (not port.type.oclIsUndefined())][getType(port.type)/];[/if]
	[/let]
	[/if]
	[comment operations /]
	[if (port.getAppliedStereotype(CSPortQN)->notEmpty())]
	[let proreq : OclAny = port.getValue(port.getAppliedStereotype(CSPortQN), 'kind')]
	[let interface : Interface = getInterface(port)]
	[if (interface <> oclIsUndefined())]
	[for (op : Operation \| interface.getOperations())]
	[proreq.toString().toUpper()/] OPERATION PORT [getOperationName(op, port)/] ([getParamList(op)/]) : [getReturn(op)/];
	[/for]
	[/if]
	[/let]
	[/let]
	[/if]
	[/let]
	[elseif (not prop.type.oclIsUndefined() and not prop.type.oclIsTypeOf(Class) and not prop.type.oclIsTypeOf(Component))]
	PARAMETER [prop.name/] : [if (not prop.type.oclIsUndefined())][getType(prop.type)/];[/if]
	[/if]
	[/for]
	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property \| p.getAppliedStereotype(ContractPropQN)->notEmpty())]
	[for (contrProp : Property \| contrProps)]
	[let contract : Class = contrProp.type.oclAsType(Class)]

	CONTRACT [contrProp.name/]
	assume:
	[getAssume(contract)/];
	guarantee:
	[getGuarantee(contract)/];
	[/let]
	[/for]
	[/let]
	[if checkWeak]

	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property \| p.getAppliedStereotype(ContractPropQN)->notEmpty() and isWeakContract(p))]
	[if (contrProps->size() > 0)]
	CONTRACT [block.name/]_allWeak
	assume:
	TRUE;
	guarantee:
	[for (contrProp : Property \| contrProps) separator (' and ')][let contract : Class = contrProp.type.oclAsType(Class)][if not isAssumptionTrue(contract)](([getAssume(contract)/]) implies [/if]([getGuarantee(contract)/])[if not isAssumptionTrue(contract)])[/if][/let][/for];
	[/if]
	[/let]
	[/if]

	REFINEMENT

	[let parts : OrderedSet(Property) = block.ownedAttribute->filter(Property)]
	[for (part : Property \| parts)]
	[if (isPart(part))]
	SUB [part.name/] : [part.type.name/];
	[/if]
	[/for]

	[let connections : Set(Connector) = block.ownedConnector]
	[for (conn : Connector \| connections)]
	[if (checkConnectedPorts(conn))]
	[comment data ports /]
	[if (checkRules(conn))]
	[if (conn.end->first().partWithPort.oclIsUndefined())]
	CONNECTION [conn.end->first().role.name/] := [conn.end->last().partWithPort.name/].[conn.end->last().role.name/];
	[elseif (conn.end->last().partWithPort.oclIsUndefined())]
	CONNECTION [conn.end->first().partWithPort.name/].[conn.end->first().role.name/] := [conn.end->last().role.name/];
	[else]
	CONNECTION [conn.end->first().partWithPort.name/].[conn.end->first().role.name/] := [conn.end->last().partWithPort.name/].[conn.end->last().role.name/];
	[/if]
	[else]
	[if (conn.end->last().partWithPort.oclIsUndefined())]
	CONNECTION [conn.end->last().role.name/] := [conn.end->first().partWithPort.name/].[conn.end->first().role.name/];
	[elseif (conn.end->first().partWithPort.oclIsUndefined())]
	CONNECTION [conn.end->last().partWithPort.name/].[conn.end->last().role.name/] := [conn.end->first().role.name/];
	[else]
	CONNECTION [conn.end->last().partWithPort.name/].[conn.end->last().role.name/] := [conn.end->first().partWithPort.name/].[conn.end->first().role.name/];
	[/if]
	[/if]
	[else]
	[comment operation ports /]
	[if (checkOperationPorts(conn))]
	[getOperationConnections(conn)/]
	[/if]
	[/if]
	[/for]
	[/let]

	[let rules : Set(Constraint) = block.ownedRule->select(c : Constraint \| c.getAppliedStereotype(DelegConstrQN)->notEmpty())]
	[for (rule : Constraint \| rules)]
	[if ((rule.specification.oclIsKindOf(OpaqueExpression) and rule.specification.oclAsType(OpaqueExpression).language.contains('OCRA')->notEmpty()))]
	[let index : Integer = rule.specification.oclAsType(OpaqueExpression).language->indexOf('OCRA')]
	[let spec : String = rule.specification.oclAsType(OpaqueExpression)._body->at(index)]
	CONNECTION [spec/][if not(spec.endsWith(';'))];[/if]
	[/let]
	[/let]
	[/if]
	[/for]
	[/let]

	[if checkWeak]
	[comment if the checkAllWeakContracts is true, then generate refinedby for all strong, and if there are any weak, then generate only one refinedby for allweak contract /]
	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property \| p.getAppliedStereotype(ContractPropQN)->notEmpty() and not isWeakContract(p))]
	[for (contrProp : Property \| contrProps)]
	[if (isRefined(contrProp))]
	[let contract : Class = contrProp.type.oclAsType(Class)]
	CONTRACT [contrProp.name/] REFINEDBY [getRefinedByStrongWeak(contrProp,parts)/]
	[/let]
	[/if]
	[/for]
	[/let]

	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property \| p.getAppliedStereotype(ContractPropQN)->notEmpty() and isWeakContract(p))]
	[let refinedByAllWeak: String = getRefinedByAllWeak(contrProps,parts)]
	[if (contrProps->size() > 0 and not refinedByAllWeak.startsWith(';'))]
	CONTRACT [block.name/]_allWeak REFINEDBY [refinedByAllWeak/]

	[/if]
	[/let]
	[/let]
	[else]
	[comment if checkAllWeakContracts is false, then generate refinedby for all selected contracts /]
	[let contrProps : OrderedSet(Property) = block.ownedAttribute->select(p : Property \| p.getAppliedStereotype(ContractPropQN)->notEmpty())]
	[for (contrProp : Property \| contrProps)]
	[if (isRefined(contrProp))]
	[let contract : Class = contrProp.type.oclAsType(Class)]
	CONTRACT [contrProp.name/] REFINEDBY [getRefinedBy(contrProp)/]
	[/let]
	[/if]
	[/for]
	[/let]
	[/if]

	[if (checkWeak)]
	[for (part : Property \| parts)]
	[if (isPart(part))]
	[let nextblock : Class = allBlocks->any(c : Class \| part.type = c)]
	[let contrProps : OrderedSet(Property) = nextblock.ownedAttribute->select(p : Property \| p.getAppliedStereotype(ContractPropQN)->notEmpty())]
	[for (contrProp : Property \| contrProps)]
	[let contract : Class = contrProp.type.oclAsType(Class)]
	[if (isWeakContract(contrProp) and not isAssumptionTrue(contract))]
	CONSISTENCY NAME [nextblock.name/]_[contrProp.name/]_consistency := [part.name/].[contrProp.name/].ASSUMPTION;
	[/if]
	[/let]
	[/for]
	[/let]
	[/let]
	[/if]
	[/for]
	[/if]

	[for (part : Property \| parts)]
	[if (isPart(part) and not isAlreadyGenerated(part.type.name, generated))]
	[let newblock : Class = allBlocks->any(c : Class \| part.type = c)]
	[generateComponent(newblock, false, allBlocks, generated,checkWeak)/]
	[/let]
	[/if]
	[/for]
	[/let]
	[/let]

	[/template]

	[query public getInterface(port : Port) : Interface =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getInterface(org.eclipse.uml2.uml.Port)', Sequence{port}) /]

	[query public getReturn(op : Operation) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getReturn(org.eclipse.uml2.uml.Operation)', Sequence{op}) /]

	[query public getParamList(op : Operation) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getParamList(org.eclipse.uml2.uml.Operation)', Sequence{op}) /]

	[query public getOperationName(op : Operation, port : Port) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getOperationName(org.eclipse.uml2.uml.Operation, org.eclipse.uml2.uml.Port)', Sequence{op, port}) /]

	[query public getSystem(classes : Set(Class), qname : String) : Class =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getSystem(java.util.Set, java.lang.String)', Sequence{classes, qname}) /]

	[query public getAllBlocks(classes : Set(Class), blockQN : String, SubSystemQN : String, SystemQN : String) : Set(Class) =
	classes->select(c : Class \| c.getAppliedStereotype(blockQN)->notEmpty() or c.getAppliedStereotype(SubSystemQN)->notEmpty() or c.getAppliedStereotype(SystemQN)->notEmpty()) /]

	[query public getAllComponents(hwcomps : Set(Component), comps : Set(Component), CompImplQN : String, PlatformQN : String) : Set(Component) =
	comps->select(c : Component \| c.getAppliedStereotype(CompImplQN)->notEmpty() or c.getAppliedStereotype(PlatformQN)->notEmpty())->union(hwcomps) /]

	[query public getDirection(dir : String) : String =
	if self='in' then 'INPUT ' else if self = 'out' then 'OUTPUT ' else '' endif endif /]

	[query public isPart(prop : Property) : Boolean =
	if self.type.oclIsTypeOf(Component) or self.type.getAppliedStereotype('CHESS::ComponentModel::ComponentImplementation')->notEmpty() or self.type.getAppliedStereotype('SysML::Blocks::Block')->notEmpty() or self.type.getAppliedStereotype('CHESSContract::SubSystem')->notEmpty() then true else false endif /]

	[query public isDelegation(conn : Connector) : Boolean =
	if (conn.end->first().partWithPort.oclIsUndefined()) xor (conn.end->last().partWithPort.oclIsUndefined())
	then true else false endif /]

	[query public firstIsSub(conn : Connector) : Boolean =
	if (conn.end->first().partWithPort.oclIsUndefined()) then false else true endif/]

	[query public getNewBlocks(parts : Set(Property)) : Set(String) =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getNewBlocks(java.util.Set)', Sequence{parts}) /]

	[query public getEmptyStringSet(traceCtx : OclAny) : Set(String) =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getEmptyStringSet()', Sequence{}) /]

	[query public addToGenerated(name : String, generated : Set(String)) : OclAny =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'addToGenerated(java.lang.String, java.util.Set)', Sequence{name, generated}) /]

	[query public isAlreadyGenerated(name : String, generated : Set(String)) : Boolean =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isAlreadyGenerated(java.lang.String, java.util.Set)', Sequence{name, generated}) /]

	[query public getAssume(contract: Class) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getAssume(org.eclipse.uml2.uml.Class)', Sequence{contract}) /]

	[query public getGuarantee(contract: Class) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getGuarantee(org.eclipse.uml2.uml.Class)', Sequence{contract}) /]

	[query public isRefined(prop : Property) : Boolean =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isRefined(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

	[query public getRefinedBy(prop : Property) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getRefinedBy(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

	[query public getRefinedByStrongWeak(prop : Property, parts : Set (Property)) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getRefinedByStrongWeak(org.eclipse.uml2.uml.Property,java.util.Set)', Sequence{prop,parts}) /]

	[query public getRefinedByAllWeak(props : Set (Property), parts : Set (Property)) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getRefinedByAllWeak(java.util.Set,java.util.Set)', Sequence{props,parts}) /]

	[query public getContractType(prop : Property) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getContractType(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

	[query public isWeakContract(prop : Property) : Boolean =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isWeakContract(org.eclipse.uml2.uml.Property)', Sequence{prop}) /]

	[query public isAssumptionTrue(contract: Class) : Boolean =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'isAssumptionTrue(org.eclipse.uml2.uml.Class)', Sequence{contract}) /]

	[query public checkRules(conn : Connector) : Boolean =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'checkRules(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

	[query public checkConnectedPorts(conn : Connector) : Boolean =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'checkConnectedPorts(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

	[query public checkOperationPorts(conn : Connector) : Boolean =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'checkOperationPorts(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

	[query public getOperationConnections(conn : Connector) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getOperationConnections(org.eclipse.uml2.uml.Connector)', Sequence{conn}) /]

	[query public getType(type : Type) : String =
	invoke('org.polarsys.chess.contracts.transformations.service.Service', 'getType(org.eclipse.uml2.uml.Type)', Sequence{type}) /]