| [comment encoding = UTF-8 /] |
| [comment |
| ----------------------------------------------------------------------- |
| -- Ada infrastructural code generator -- |
| -- for the CHESS component model -- |
| -- -- |
| -- Copyright (C) 2011-2012 -- |
| -- University of Padova, ITALY -- |
| -- -- |
| -- Author: Marco Panunzio panunzio@math.unipd.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 -- |
| ----------------------------------------------------------------------- |
| /] |
| [module Container('http://www.eclipse.org/uml2/3.0.0/UML', |
| 'http://CHESS/Predictability/RTComponentModel')/] |
| [import org::polarsys::chess::codegen::ada::main::Copyright /] |
| |
| [template public generateContainer(model : Model, procNode: InstanceSpecification, instSpec : InstanceSpecification, cImpl : Component) { |
| pkgName : String = 'CT_'.concat(instSpec.name.replaceAll('\\.','_')).replaceAll('\\.', '_').concat('s'); |
| procNodeName : String = procNode.name; |
| ptList : Sequence(Port) = instSpec.classifier.oclAsType(Component).ownedAttribute->asSequence()->filter(Port); |
| clSvPortStName : String = 'MARTE::MARTE_DesignModel::GCM::ClientServerPort'; |
| CHRtPortStName : String = 'CHESS::Dependability::RTComponentModel::CHRtPortSlot'; |
| CHRtSpecificationStName : String = 'CHESS::Dependability::RTComponentModel::CHRtSpecification'; |
| cType : Component = cImpl.clientDependency.supplier->asSequence()->first().oclAsType(Component); |
| instTypePkg : String = cType.name.concat('s.').concat(cImpl.name).concat('s'); |
| slotSeq : Sequence(OclAny) = instSpec.slot->asSequence(); |
| cyclicOpList : Sequence(Operation) = getCyclicOperationList(slotSeq, CHRtPortStName)->filter(Operation); |
| sporadicOpList : Sequence(Operation) = getSporadicOperationList(slotSeq, CHRtPortStName)->filter(Operation); |
| protectedOpList : Sequence(Operation) = getProtectedOperationList(slotSeq, CHRtPortStName)->filter(Operation); |
| unprotectedOpList : Sequence(Operation) = getUnprotectedOperationList(slotSeq, CHRtPortStName)->filter(Operation); |
| providedIntList : Sequence(Interface) = getProvidedInterfaceList(ptList, clSvPortStName) |
| } |
| ] |
| |
| [file (procNodeName.concat('/src/container/').concat(pkgName).concat('.ads').toLower(), false, 'UTF-8')] |
| [generateCopyrightAda(model) /] |
| |
| [comment With section /] |
| -- Comment the with below if you do not use user-defined datatypes |
| with Datatype; use Datatype; |
| |
| [comment With of interface packages/] |
| -- with of interface and component implementation packages |
| [for (aInterface: Interface | getProvidedInterfaceList(ptList, clSvPortStName)->filter(Interface))] |
| with [aInterface.name/]; |
| [/for] |
| [for (aInterface: Interface | getRequiredInterfaceList(ptList, clSvPortStName)->filter(Interface))] |
| with [aInterface.name/]; |
| [/for] |
| [comment With of the component implementation/] |
| with [cType.name/]s.[cImpl.name/]s; |
| [comment With of packages to enforce extra-functional properties/] |
| |
| --with of packages for enforcement of extra-functional properties |
| [for (str: String | getPackageToWithSpec(slotSeq, CHRtPortStName, CHRtSpecificationStName)->filter(String))] |
| [str/] |
| [/for] |
| |
| |
| package [pkgName/] is |
| |
| procedure Initialize_Container; |
| |
| -- Getter subprograms for provided interfaces |
| [for (aInterface: Interface | getProvidedInterfaceList(ptList, clSvPortStName)->filter(Interface))] |
| function Get_[aInterface.name/] return [aInterface.name/].[aInterface.name/]_ptr; |
| |
| [/for] |
| |
| -- Setter subprograms for required interfaces |
| [for (pt : Port | ptList)] |
| [if (isRequiredPort(pt, clSvPortStName))] |
| procedure Set_[pt.name/] (ptr : in [getRequiredInterface(pt, clSvPortStName).name/].[getRequiredInterface(pt, clSvPortStName).name/]_ptr); |
| [/if] |
| [/for] |
| |
| private |
| |
| -- Component instance |
| [instSpec.name.replaceAll('\\.','_')/]: aliased [instTypePkg/].[cImpl.name/]; |
| -- Access pointers to the instance (1 x PI) |
| [for (aInterface: Interface | getProvidedInterfaceList(ptList, clSvPortStName)->filter(Interface))] |
| [instSpec.name.replaceAll('\\.','_')/]_as_[aInterface.name/]_ptr : [aInterface.name/].[aInterface.name/]_ptr := [instSpec.name.replaceAll('\\.','_')/]'access; |
| [/for] |
| |
| -- Type definition for the container |
| type ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T is new [getProvidedInterfaceListAsQualifiedString(ptList, clSvPortStName)/] with null record; |
| |
| -- Overriding of operations of interfaces |
| [for (op: Operation | cImpl.ownedOperation)] |
| |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| overriding |
| function [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T) return [getReturnParam(op).type.name/]; |
| [else] |
| overriding |
| function [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T [for (par : Parameter | op.ownedParameter)][if(not par.direction.toString().equalsIgnoreCase('return'))]; |
| [par.name/] : [par.direction/] [par.type.name/][/if][/for]) return [getReturnParam(op).type.name/]; |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] |
| overriding |
| procedure [op.name /] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T)[if (isCyclicOperation(slotSeq, op, CHRtPortStName))] is null[/if]; |
| [else] |
| overriding |
| procedure [op.name/] (Self: in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T[for (par : Parameter | op.ownedParameter)]; |
| [par.name/] : [if(par.direction.toString().equalsIgnoreCase('return'))]out[else][par.direction/][/if] [par.type.name/][/for]); |
| [/if] |
| [/if] |
| [/for] |
| |
| -- Instantiation of the container |
| ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T_inst_0 : aliased ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T; |
| |
| |
| |
| -- Entities for the enforcement of extra-functional properties -- |
| [comment Cyclic operations /] |
| [for (op : Operation | cyclicOpList)] |
| |
| -- Wrapper procedure for the cyclic operation |
| procedure [op.name/]; |
| |
| procedure Enqueueing_Procedure_My_Thread_[i-1/] (Release : out Time); |
| |
| My_CPA_[i-1/] : aliased Release_Control_OBCS([getCeiling(slotSeq, op, CHRtPortStName)/]); |
| |
| [if (isMonitored(slotSeq, op, CHRtPortStName))] |
| Name : constant access String := new String'("[getMonitoredTaskName(slotSeq, op, CHRtPortStName)/]"); |
| |
| My_Thread_[i-1/] : aliased Cyclic_Task_Monitored.Thread_T(Data_Structure.Generate_Task_ID, [getPriority(slotSeq, op, CHRtPortStName)/], 0, [getPeriodOrMIAT(slotSeq, op, CHRtPortStName)/], |
| Enqueueing_Procedure_My_Thread_[i-1/]'access, [op.name/]'access, Name); |
| [else] |
| My_Thread_[i-1/] : aliased Cyclic_Task.Thread_T(Data_Structure.Generate_Task_ID, [getPriority(slotSeq, op, CHRtPortStName)/], 0, [getPeriodOrMIAT(slotSeq, op, CHRtPortStName)/], |
| Enqueueing_Procedure_My_Thread_[i-1/]'access, [op.name/]'access); |
| [/if] |
| [/for] |
| [comment end Cyclic operations /] |
| [comment Sporadic operations /] |
| [if (sporadicOpList->notEmpty()) ] |
| -- Configuration parameters for all queues and OBCS |
| Param_Queue_Size : constant Integer := 3; |
| OBCS_Queue_Size : constant Integer := Param_Queue_Size * 2; |
| |
| -- Instantiation of queues and OBCS |
| [/if] |
| [for (op : Operation | sporadicOpList)] |
| [let aInterface : Interface = getInterface(op, ptList, clSvPortStName)] |
| [op.name/]_OBCS_Ceiling : System.Priority := [getCeiling(slotSeq, op, CHRtPortStName)/]; |
| |
| type [op.name/]_Param_T is new Data_Structure.Param_Type with record |
| OPCS_Instance : [aInterface.name/].[aInterface.name/]_ptr; |
| [for (par : Parameter | op.ownedParameter)] |
| [par.name/] : [par.type.name/]; |
| [/for] |
| end record; |
| type [op.name/]_Param_T_Ref is access all [op.name/]_Param_T; |
| |
| type [op.name/]_Param_Arr is array(Integer range <>) of aliased [op.name/]_Param_T; |
| |
| overriding |
| procedure My_OPCS(Self : in out [op.name/]_Param_T); |
| |
| -- create an OBCS that matches the interface of the OPCS |
| protected type [op.name/]_OBCS(Ceiling : System.Any_Priority; |
| [op.name/]_Params_Arr_Ref_P : Data_Structure.Param_Arr_Ref) is |
| pragma Priority(Ceiling); |
| entry Get_Request(Req : out Data_Structure.Request_Descriptor_T; |
| Release : out Time); |
| |
| -- Subprograms |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| procedure [op.name/]; |
| [else] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [if (parList->size() = 1)] [comment 1 parameter /] |
| procedure [op.name/] ([parList->first().name/] : [if(parList->first().direction.toString().equalsIgnoreCase('return'))]out[else][parList->first().direction/][/if] [parList->first().type.name/]); |
| [else] [comment more than 1 parameter/] |
| procedure [op.name/] ([for (par : Parameter | parList)] |
| [par.name/] : [if(par.direction.toString().equalsIgnoreCase('return'))]out[else][par.direction/][/if] [par.type.name/][if not(par = parList->last())];[/if][/for]); |
| [/if] |
| [/let] |
| [/if] |
| |
| private |
| -- The queue system for [op.name/]_OBCS |
| [op.name/]_OBCS_Queue : Data_Structure.Request_Queue(OBCS_Queue_Size); |
| -- Arrays to store a set of reified invocations for [op.name/] |
| [op.name/]_Params : Data_Structure.Param_Buffer_T(Param_Queue_Size) := |
| (Size => Param_Queue_Size, Index => 1, Buffer => [op.name/]_Params_Arr_Ref_P.all); |
| Pending : Standard.Boolean := False; |
| end [op.name/]_OBCS; |
| [/let] |
| [/for] |
| [comment End Sporadic operations /] |
| [comment Protected operations /] |
| [for (sl : Slot | slotSeq->filter(Slot))] |
| [let protectedOpList : Sequence(Operation) = getSlotProtectedOperation(sl, CHRtPortStName)] |
| [if (protectedOpList->notEmpty())] |
| |
| [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO_Ceiling : System.Priority := [getCeiling(slotSeq, protectedOpList->first(), CHRtPortStName)/]; |
| |
| protected type [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO is |
| pragma Priority([instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO_Ceiling); |
| |
| -- Subprograms |
| [for (op : Operation | protectedOpList)] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| function [op.name/] return [getReturnParam(op).type.name/]; |
| [else] |
| [let parmListNoReturn : OrderedSet(Parameter) = parList->excluding(getReturnParam(op))] |
| function [op.name/]([for (par : Parameter | parmListNoReturn)][par.name/] : [par.direction/] [par.type.name/][if (not(par = parmListNoReturn->last()))]; [/if][/for]) return [getReturnParam(op).type.name/]; |
| [/let] |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| procedure [op.name/]; |
| [else] |
| procedure [op.name/] ([for (par : Parameter | parList)][par.name/] : [if(par.direction.toString().equalsIgnoreCase('return'))]out[else][par.direction/][/if] [par.type.name/][if not( par = parList->last())]; [/if][/for]); |
| [/if] |
| [/if] |
| [/let] |
| [/for] |
| |
| private |
| |
| end [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO; |
| [/if] |
| [/let] |
| [/for] |
| [comment end Protected Operations /] |
| |
| end [pkgName/]; |
| [/file] |
| |
| [file (procNodeName.concat('/src/container/').concat(pkgName).concat('.adb').toLower(), false, 'UTF-8')] |
| [generateCopyrightAda(model)/] |
| |
| [comment Package "Sporadic_Task" is to be with'ed if there is at |
| least one sporadic operation to be supported /] |
| [if (sporadicOpList->notEmpty())] |
| -- with Sporadic_Task; |
| with Sporadic_Task_Monitored; |
| |
| -- With of data types and Default Values. |
| -- Remove it if it is already included in the spec. |
| with Datatype; use Datatype; |
| [/if] |
| --with Ada.Text_IO; |
| |
| package body [pkgName/] is |
| |
| |
| procedure Initialize_Container is |
| begin |
| --Ada.Text_IO.Put_Line("-- Container [pkgName/].Initialize_Container -- "); |
| null; |
| end Initialize_Container; |
| |
| [comment getters for Provided Interfaces /] |
| -- Getter subprograms for Provided Interfaces |
| |
| [for (aInterface: Interface | getProvidedInterfaceList(ptList, clSvPortStName)->filter(Interface))] |
| function Get_[aInterface.name/] return [aInterface.name/].[aInterface.name/]_ptr is |
| begin |
| return ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T_inst_0'access; |
| end Get_[aInterface.name/]; |
| |
| [/for] |
| |
| [comment setters for Required Interfaces /] |
| -- Setter subprograms for Required Interfaces |
| |
| [for (pt : Port | ptList)] |
| [if (isRequiredPort(pt, clSvPortStName))] |
| procedure Set_[pt.name/] (ptr : in [getRequiredInterface(pt, clSvPortStName).name/].[getRequiredInterface(pt, clSvPortStName).name/]_ptr) is |
| use type [getRequiredInterface(pt, clSvPortStName).name/].[getRequiredInterface(pt, clSvPortStName).name/]_ptr; |
| begin |
| if ptr /= null then |
| [instSpec.name.replaceAll('\\.','_')/].Set_[pt.name/](ptr); |
| end if; |
| end Set_[pt.name/]; |
| [/if] |
| |
| [/for] |
| |
| [comment Cyclic operations BODY /] |
| [for (op : Operation | cyclicOpList)] |
| procedure Enqueueing_Procedure_My_Thread_[i-1/] (Release : out Time) is |
| begin |
| My_CPA_[i-1/].Enqueue_for_Release(Release); |
| end Enqueueing_Procedure_My_Thread_[i-1/]; |
| |
| -- Wrapper procedure for the cyclic operation |
| procedure [op.name/] is |
| begin |
| [instSpec.name.replaceAll('\\.','_')/].[op.name/]; |
| end [op.name/]; |
| |
| [/for] |
| [comment end Cyclic operations BODY /] |
| [comment Sporadic operations BODY /] |
| [for (op : Operation | sporadicOpList)] |
| [let aInterface : Interface = getInterface(op, ptList, clSvPortStName)] |
| |
| -- Redefinition of My_OPCS. |
| -- Call [op.name/] and set In_Use to false. |
| procedure My_OPCS(Self : in out [op.name/]_Param_T) is |
| begin |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| Self.OPCS_Instance.[op.name/]; |
| [else] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [if (parList->size() = 1)] [comment 1 parameter /] |
| Self.OPCS_Instance.[op.name/](Self.[parList->first().name/]); |
| [else] [comment more than 1 parameter/] |
| Self.OPCS_Instance.[op.name/](Self.[parList->first().name/],[for (par : Parameter | parList->excluding(parList->first())->asOrderedSet())]Self.[par.name/][/for]); |
| [/if] |
| [/let] |
| [/if] |
| Self.In_Use := False; |
| end My_OPCS; |
| |
| protected body [op.name/]_OBCS is |
| |
| procedure Update_Barrier is |
| begin |
| Pending := ([op.name/]_OBCS_Queue.Request_Pending) > 0; |
| end Update_Barrier; |
| |
| -- Get_Request stores the time of the release of the task, |
| -- gets the next request (according to the OBCS queueing policy), |
| -- and updates the guard. |
| entry Get_Request (Req : out Data_Structure.Request_Descriptor_T; |
| Release : out Time) |
| when Pending is |
| begin |
| -- Ada.Text_IO.Put_Line("OBCS: Executing entry Get_Request"); |
| Release := Clock; |
| Data_Structure.Get([op.name/]_OBCS_Queue, Req); |
| Update_Barrier; |
| end Get_Request; |
| |
| -- When a client calls [op.name/], the request is reified and put in the OBCS queue. |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| procedure [op.name/] is |
| [else] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [if (parList->size() = 1)] [comment 1 parameter /] |
| procedure [op.name/] ([parList->first().name/] : [parList->first().direction/] [parList->first().type.name/]) is |
| [else] [comment more than 1 parameter/] |
| procedure [op.name/] ([parList->first().name/] : [parList->first().direction/] [parList->first().type.name/][for (par : Parameter | parList->excluding(parList->first())->asOrderedSet())]; |
| [par.name/] : [par.direction/] [par.type.name/][/for]) is |
| [/if] |
| [/let] |
| [/if] |
| begin |
| --Ada.Text_IO.Put_Line("OBCS: [op.name/]"); |
| if [op.name/]_Params.Buffer([op.name/]_Params.Index).In_Use then |
| Data_Structure.Increase_Index([op.name/]_Params); |
| end if; |
| |
| [for (par : Parameter | op.ownedParameter)] |
| [op.name/]_Param_T_Ref([op.name/]_Params.Buffer([op.name/]_Params.Index)).[par.name/] := [par.name/]; |
| [/for] |
| Data_Structure.Put([op.name/]_OBCS_Queue, [op.name/]_Params.Buffer([op.name/]_Params.Index)); |
| Data_Structure.Increase_Index([op.name/]_Params); |
| Update_Barrier; |
| end [op.name/]; |
| end [op.name/]_OBCS; |
| |
| [op.name/]_Par_Arr : [op.name/]_Param_Arr(1..Param_Queue_Size):= |
| (others => (In_Use => false, |
| OPCS_Instance => [instSpec.name.replaceAll('\\.','_')/]'access, |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [if (parList->size() > 0)] |
| [parList->first().name/] => [parList->first().type.name/]_Default_Value[for (par : Parameter | parList->excluding(parList->first())->asOrderedSet())], |
| [par.name/] => [par.type.name/]_Default_Value [/for])); |
| [/if] |
| [/let] |
| |
| [op.name/]_Ref_Par_Arr : aliased Data_Structure.Param_Arr := |
| ([op.name/]_Par_Arr(1)'access, |
| [op.name/]_Par_Arr(2)'access, |
| [op.name/]_Par_Arr(3)'access); |
| |
| |
| -- Instance of OBCS |
| [op.name/]_OBCS_inst : aliased [op.name/]_OBCS([op.name/]_OBCS_Ceiling, [op.name/]_Ref_Par_Arr'access); |
| |
| -- Wrapper for OBCS_inst entry |
| procedure Enqueue_in_Entry_[op.name/](Req : out Data_Structure.Request_Descriptor_T; |
| Release : out Time) is |
| begin |
| [op.name/]_OBCS_inst.Get_Request(Req, Release); |
| end Enqueue_in_Entry_[op.name/]; |
| |
| -- Sporadic Task |
| |
| [if (isMonitored(slotSeq, op, CHRtPortStName))] |
| Name : constant access String := new String'("[getMonitoredTaskName(slotSeq, op, CHRtPortStName)/]"); |
| My_Thread_[i-1/] : aliased Sporadic_Task_Monitored.Thread_T(Data_Structure.Generate_Task_ID, [getPriority(slotSeq, op, CHRtPortStName)/], [getPeriodOrMIAT(slotSeq, op, CHRtPortStName)/], |
| Enqueue_In_Entry_[op.name/]'access, Name); |
| [else] |
| |
| My_Thread_[i-1/] : aliased Sporadic_Task.Thread_T(Data_Structure.Generate_Task_ID, [getPriority(slotSeq, op, CHRtPortStName)/], [getPeriodOrMIAT(slotSeq, op, CHRtPortStName)/], |
| Enqueue_In_Entry_[op.name/]'access); |
| [/if] |
| [if (op.ownedParameter->size() = 0)] |
| procedure [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T) is |
| [else] |
| procedure [op.name/] (Self: in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T[for (par : Parameter | op.ownedParameter)]; |
| [par.name/] : [par.direction/] [par.type.name/][/for]) is |
| [/if] |
| pragma Warnings (Off, Self); |
| begin |
| --Ada.Text_IO.Put_Line("Container ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/] : Reifiying [op.name/] call to OBCS "); |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| [op.name/]_OBCS_inst.[op.name/]; |
| [else] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [op.name/]_OBCS_inst.[op.name/]([parList->first().name/][for (par : Parameter | parList->excluding(parList->first())->asOrderedSet())], [par.name/][/for]); |
| [/let] |
| [/if] |
| end [op.name/]; |
| |
| [/let] |
| [/for] |
| [comment End Sporadic operations BODY /] |
| [comment Protected operations BODY /] |
| [for (sl : Slot | slotSeq->filter(Slot))] |
| [let protectedOpList : Sequence(Operation) = getSlotProtectedOperation(sl, CHRtPortStName)] |
| [if (protectedOpList->notEmpty())] |
| |
| -- Instance of [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/] protected object |
| [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO_inst : aliased [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO; |
| |
| protected body [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO is |
| |
| [for (op : Operation | protectedOpList)] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| function [op.name/] return [getReturnParam(op).type.name/] is |
| [else] |
| [let parmListNoReturn : OrderedSet(Parameter) = parList->excluding(getReturnParam(op))] |
| function [op.name/]([for (par : Parameter | parmListNoReturn)][par.name/] : [par.direction/] [par.type.name/][if (not(par = parmListNoReturn->last()))]; [/if][/for]) return [getReturnParam(op).type.name/] is |
| [/let] |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| procedure [op.name/] is |
| [else] |
| procedure [op.name/] ([for (par : Parameter | parList)][par.name/] : [if(par.direction.toString().equalsIgnoreCase('return'))]out[else][par.direction/][/if] [par.type.name/][if not( par = parList->last())]; [/if][/for]) is |
| [/if] |
| [/if] |
| [/let] |
| begin |
| --Ada.Text_IO.Put_Line("PO.[op.name/]"); |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| return [instSpec.name.replaceAll('\\.','_')/].[op.name/]; |
| [else] |
| [let parmListNoReturn : OrderedSet(Parameter) = op.ownedParameter->excluding(getReturnParam(op))] |
| return [instSpec.name.replaceAll('\\.','_')/].[op.name/]([for (par : Parameter | parmListNoReturn)][par.name/][if not(par = parmListNoReturn->last())], [/if][/for]); |
| [/let] |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| [instSpec.name.replaceAll('\\.','_')/].[op.name/]; |
| [else] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [instSpec.name.replaceAll('\\.','_')/].[op.name/]([for (par : Parameter | parList)][par.name/][if not(par = parList->last())], [/if][/for]); |
| [/let] |
| [/if] |
| [/if] |
| end [op.name/]; |
| |
| [/for] |
| end [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO; |
| |
| -- Redefinition of procedures of the container |
| [for (op : Operation | protectedOpList)] |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| function [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T) return [getReturnParam(op).type.name/] is |
| [else] |
| [let parmListNoReturn : OrderedSet(Parameter) = op.ownedParameter->excluding(getReturnParam(op))] |
| function [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T[for (par : Parameter | parmListNoReturn)]; |
| [par.name/] : [par.direction/] [par.type.name/][/for]) return [getReturnParam(op).type.name/] is |
| [/let] |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] |
| procedure [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T) is |
| [else] |
| procedure [op.name/] (Self: in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T[for (par : Parameter | op.ownedParameter)]; |
| [par.name/] : [par.direction/] [par.type.name/][/for]) is |
| [/if] |
| [/if] |
| pragma Warnings (Off, Self); |
| begin |
| --Ada.Text_IO.Put_Line("Container ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/] : Indirection to PO.[op.name/]"); |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| return [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO_inst.[op.name/]; |
| [else] |
| [let parmListNoReturn : OrderedSet(Parameter) = op.ownedParameter->excluding(getReturnParam(op))] |
| return [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO_inst.[op.name/]([for (par : Parameter | parmListNoReturn)][par.name/][if not(par = parmListNoReturn->last())], [/if][/for]); |
| [/let] |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO_inst.[op.name/]; |
| [else] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [instSpec.name.replaceAll('\\.','_')/]_[sl.definingFeature.name/]_PO_inst.[op.name/]([for (par : Parameter | parList)][par.name/][if not(par = parList->last())], [/if][/for]); |
| [/let] |
| [/if] |
| [/if] |
| end [op.name/]; |
| [/for] |
| [/if] |
| [/let] |
| [/for] |
| [comment End protected operations /] |
| [comment Unprotected Operations /] |
| [for (op: Operation | unprotectedOpList)] |
| |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| function [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T) return [getReturnParam(op).type.name/] is |
| [else] |
| [let parmListNoReturn : OrderedSet(Parameter) = op.ownedParameter->excluding(getReturnParam(op))] |
| function [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T [for (par : Parameter | parmListNoReturn)]; [par.name/] : [par.direction/] [par.type.name/][/for]) return [getReturnParam(op).type.name/] is |
| [/let] |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] |
| procedure [op.name/] (Self : in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T) is |
| [else] |
| procedure [op.name/] (Self: in out ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/]_T[for (par : Parameter | op.ownedParameter)]; |
| [par.name/] : [par.direction/] [par.type.name/][/for]) is |
| [/if] |
| [/if] |
| pragma Warnings (Off, Self); |
| begin |
| --Ada.Text_IO.Put_Line("Container ['CT_'.concat(instSpec.name.replaceAll('\\.','_'))/] : Unprotected execution of [op.name/]"); |
| [if (isFunction(op))] |
| [if (op.ownedParameter->size() = 1)] |
| return [instSpec.name.replaceAll('\\.','_')/].[op.name/]; |
| [else] |
| [let parmListNoReturn : OrderedSet(Parameter) = op.ownedParameter->excluding(getReturnParam(op))] |
| return [instSpec.name.replaceAll('\\.','_')/].[op.name/]([for (par : Parameter | parmListNoReturn)][par.name/][if not(par = parmListNoReturn->last())], [/if][/for]); |
| [/let] |
| [/if] |
| [else] |
| [if (op.ownedParameter->size() = 0)] [comment 0 parameters/] |
| [instSpec.name.replaceAll('\\.','_')/].[op.name/]; |
| [else] |
| [let parList : OrderedSet(Parameter) = op.ownedParameter] |
| [instSpec.name.replaceAll('\\.','_')/].[op.name/]([for (par : Parameter | parList)][par.name/][if not(par = parList->last())], [/if][/for]); |
| [/let] |
| [/if] |
| [/if] |
| end [op.name/]; |
| [/for] |
| [comment end Unprotected Operations /] |
| |
| end [pkgName/]; |
| [/file] |
| |
| [/template] |
| |
| [query public getRequiredInterface(arg0 : Port, arg1 : String) : Interface |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getRequiredInterface(org.eclipse.uml2.uml.Port, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public isRequiredPort(arg0 : Port, arg1 : String) : Boolean |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'isRequiredPort(org.eclipse.uml2.uml.Port, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getProvidedInterfaceList(arg0 : Sequence(OclAny), arg1 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getProvidedInterfaceList(java.util.List, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getProvidedInterfaceListAsQualifiedString(arg0 : Sequence(OclAny), arg1 : String) : String |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getProvidedInterfaceListAsQualifiedString(java.util.List, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getRequiredInterfaceList(arg0 : Sequence(OclAny), arg1 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getRequiredInterfaceList(java.util.List, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getPackageToWithSpec(arg0 : Sequence(OclAny), arg1 : String, arg2 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getPackageToWithSpec(java.util.List, java.lang.String, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public getPriority(arg0 : Sequence(OclAny), arg1 : Operation, arg2 : String) : String |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getPriority(java.util.List, org.eclipse.uml2.uml.Operation, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public isMonitored(arg0 : Sequence(OclAny), arg1 : Operation, arg2 : String) : Boolean |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'isMonitored(java.util.List, org.eclipse.uml2.uml.Operation, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public getMonitoredTaskName(arg0 : Sequence(OclAny), arg1 : Operation, arg2 : String) : String |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getMonitoredTaskName(java.util.List, org.eclipse.uml2.uml.Operation, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public getPeriodOrMIAT(arg0 : Sequence(OclAny), arg1 : Operation, arg2 : String) : String |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getPeriodOrMIAT(java.util.List, org.eclipse.uml2.uml.Operation, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public getCeiling(arg0 : Sequence(OclAny), arg1 : Operation, arg2 : String) : String |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getCeiling(java.util.List, org.eclipse.uml2.uml.Operation, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public getCyclicOperationList(arg0 : Sequence(OclAny), arg1 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getCyclicOperationList(java.util.List, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getSporadicOperationList(arg0 : Sequence(OclAny), arg1 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getSporadicOperationList(java.util.List, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getProtectedOperationList(arg0 : Sequence(OclAny), arg1 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getProtectedOperationList(java.util.List, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getUnprotectedOperationList(arg0 : Sequence(OclAny), arg1 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getUnprotectedOperationList(java.util.List, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public getSlotProtectedOperation(arg0 : Slot, arg1 : String) : Sequence(OclAny) |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getSlotProtectedOperation(org.eclipse.uml2.uml.Slot, java.lang.String)', Sequence{arg0, arg1}) /] |
| |
| [query public isCyclicOperation(arg0 : Sequence(OclAny), arg1 : Operation, arg2 : String) : Boolean |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'isCyclicOperation(java.util.List, org.eclipse.uml2.uml.Operation, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public getInterface(arg0 : Operation, arg1 : Sequence(OclAny), arg2 : String) : Interface |
| = invoke('org.polarsys.chess.codegen.ada.service.UML2Service', 'getInterface(org.eclipse.uml2.uml.Operation, java.util.List, java.lang.String)', Sequence{arg0, arg1, arg2}) /] |
| |
| [query public isFunction(arg : Operation) : Boolean |
| = invoke ('org.polarsys.chess.codegen.ada.service.UML2Service', 'isFunction(org.eclipse.uml2.uml.Operation)', Sequence{arg}) /] |
| |
| [query public getReturnParam(arg : Operation) : Parameter |
| = invoke ('org.polarsys.chess.codegen.ada.service.UML2Service', 'getReturnParam(org.eclipse.uml2.uml.Operation)', Sequence{arg}) /] |
