armodel 1.4.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

armodel/models/bsw_module_template.py

@@ -1,8 +1,10 @@
 from abc import ABCMeta
 from typing import Dict, List
+
+from .internal_behavior import IncludedDataTypeSet, InternalBehavior
 from .general_structure import AtpStructureElement, ARObject, ARElement
 from .ar_object import ARBoolean, ARFloat, ARLiteral, ARNumerical, ARPositiveInteger
-from .common_structure import ExecutableEntity, ModeDeclarationGroupPrototype, InternalBehavior, Identifiable
+from .common_structure import ExecutableEntity, IncludedModeDeclarationGroupSet, ModeDeclarationGroupPrototype, Identifiable
 from .ar_ref import RefType
 
 class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
@@ -13,14 +15,35 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
 
         self.accessedModeGroupRefs = []                 # type: List[RefType]
         self.activationPointRefs = []                   # type: List[RefType]
-        self.implemented_entry_ref = None                 # type: RefType
-        self._managedModeGroupRefs = []                 # type: List[RefType]
+        self.implementedEntryRef = None                 # type: RefType
+        self.managedModeGroupRefs = []                  # type: List[RefType]
+
+    def getAccessedModeGroupRefs(self):
+        return self.accessedModeGroupRefs
+
+    def addAccessedModeGroupRefs(self, value):
+        self.accessedModeGroupRefs.append(value)
+        return self
+
+    def getActivationPointRefs(self):
+        return self.activationPointRefs
+
+    def addActivationPointRefs(self, value):
+        self.activationPointRefs.append(value)
+        return self
+
+    def getImplementedEntryRef(self):
+        return self.implementedEntryRef
+
+    def setImplementedEntryRef(self, value):
+        self.implementedEntryRef = value
+        return self
 
     def addManagedModeGroupRef(self, ref: RefType):
-        self._managedModeGroupRefs.append(ref)
+        self.managedModeGroupRefs.append(ref)
 
     def getManagedModeGroupRefs(self) -> List[RefType]:
-        return self._managedModeGroupRefs
+        return self.managedModeGroupRefs
 
 class BswCalledEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
@@ -105,7 +128,6 @@ class BswInternalTriggerOccurredEvent(BswScheduleEvent):
 
         self.event_source_ref = None                # type: RefType
 
-
 class BswModeSwitchAckRequest(ARObject):
     def __init__(self):
         super().__init__()
@@ -144,21 +166,23 @@ class BswInternalBehavior(InternalBehavior):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._entities = []                         # type: List[BswModuleEntity]
-        self._events = []                           # type: List[BswEvent]
-        self._mode_sender_policies = []             # type: List[BswModeSenderPolicy]
+        self.entities = []                                  # type: List[BswModuleEntity]
+        self.events = []                                    # type: List[BswEvent]
+        self.mode_sender_policies = []                      # type: List[BswModeSenderPolicy]
+        self.included_mode_declaration_group_sets = []      # type: List[IncludedModeDeclarationGroupSet]
+        self.included_data_type_sets = []                       # type: List[IncludedDataTypeSet]
 
     def addModeSenderPolicy(self, policy: BswModeSenderPolicy):
-        self._mode_sender_policies.append(policy)
+        self.mode_sender_policies.append(policy)
 
     def getModeSenderPolicies(self) -> List[BswModeSenderPolicy]:
-        return self._mode_sender_policies
+        return self.mode_sender_policies
 
     def createBswCalledEntity(self, short_name: str) -> BswCalledEntity:
         if (short_name not in self.elements):
             event = BswCalledEntity(self, short_name)
             self.elements[short_name] = event
-            self._entities.append(event)
+            self.entities.append(event)
         return self.elements[short_name]
 
     def getBswCalledEntities(self) -> List[BswCalledEntity]:
@@ -168,7 +192,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswSchedulableEntity(self, short_name)
             self.elements[short_name] = event
-            self._entities.append(event)
+            self.entities.append(event)
         return self.elements[short_name]
 
     def getBswSchedulableEntities(self) -> List[BswSchedulableEntity]:
@@ -181,7 +205,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswModeSwitchEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswModeSwitchEvents(self) -> List[BswModeSwitchEvent]:
@@ -191,7 +215,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswTimingEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswTimingEvents(self) -> List[BswTimingEvent]:
@@ -201,7 +225,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswDataReceivedEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswDataReceivedEvents(self) -> List[BswDataReceivedEvent]:
@@ -211,7 +235,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswInternalTriggerOccurredEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswInternalTriggerOccurredEvents(self) -> List[BswInternalTriggerOccurredEvent]:
@@ -219,8 +243,20 @@ class BswInternalBehavior(InternalBehavior):
     
     def getBswEvents(self) -> List[BswEvent]:
         return list(filter(lambda a: isinstance(a, BswEvent), self.elements.values()))
+    
+    def addIncludedModeDeclarationGroupSet(self, group_set: IncludedModeDeclarationGroupSet):
+        self.included_mode_declaration_group_sets.append(group_set)
 
-class BswModuleDescription(AtpStructureElement):
+    def getIncludedModeDeclarationGroupSets(self) -> List[IncludedModeDeclarationGroupSet]:
+        return self.included_mode_declaration_group_sets
+    
+    def addIncludedDataTypeSet(self, type_set: IncludedDataTypeSet):
+        self.included_data_type_sets.append(type_set)
+
+    def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
+        return self.included_data_type_sets
+
+class BswModuleDescription(ARElement):
     '''
         Root element for the description of a single BSW module or BSW cluster. In case it
         describes a BSW module, the short name of this element equals the name of the
@@ -239,7 +275,7 @@ class BswModuleDescription(AtpStructureElement):
         self._implementedEntryRefs = []                 # type: List[RefType]
 
         self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
-        self.requiredModeGroups   = {}                  # tyep: Dict[str, ModeDeclarationGroupPrototype] 
+        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
 
     def addImplementedEntry(self, entry_ref: RefType):
         self._implementedEntryRefs.append(entry_ref)
@@ -247,15 +283,17 @@ class BswModuleDescription(AtpStructureElement):
     def getImplementedEntries(self) -> List[RefType]:
         return self._implementedEntryRefs
 
-    @property
-    def category(self) -> str:
-        return self._category
-
-    @category.setter
-    def category(self, value:str):
-        if value not in ("BSW_MODULE", "BSW_CLUSTER", "LIBRARY"):
-            raise ValueError("Invalid category <%s> of BswModuleDescription <%s>" % (value, self.short_name))
-        self._category = value
+    #@property
+    #def category(self) -> str:
+    #    return ARElement.getCategory(self)
+
+    #@category.setter
+    #def category(self, value:str):
+    #    if value is None:
+    #        return
+    #    if value not in ("BSW_MODULE", "BSW_CLUSTER", "LIBRARY"):
+    #        raise ValueError("Invalid category <%s> of BswModuleDescription <%s>" % (value, self.short_name))
+    #    ARElement.setCategory(self, value)
 
     def createProvidedModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
         if (short_name not in self.elements):

armodel/models/common_structure.py

@@ -3,141 +3,72 @@
 from abc import ABCMeta
 from typing import List
 
-from .ar_object import ARFloat, ARLiteral, ARNumerical
-from .general_structure import ARObject, ARElement, Identifiable
-from .data_dictionary import SwDataDefProps
+from .ar_object import ARBoolean, ARFloat, ARLiteral, ARNumerical
+from .general_structure import ARObject, Identifiable
+from .m2.msr.data_dictionary.data_def_properties import SwDataDefProps
 from .ar_ref import RefType, TRefType
 
 import re
 
-class ValueSpecification(ARObject, metaclass=ABCMeta):
-    '''
-    Base class for expressions leading to a value which can be used to initialize a data object.
-    
-    Base        : ARObject
-    Subclasses  : AbstractRuleBasedValueSpecification, ApplicationValueSpecification, CompositeValueSpecification,
-                  ConstantReference, NotAvailableValueSpecification, NumericalValueSpecification, ReferenceValueSpecification, 
-                  TextValueSpecification
-    '''
-    def __init__(self):
-        if type(self) == ValueSpecification:
-            raise NotImplementedError("ValueSpecification is an abstract class.")
-        
-        super().__init__()
-
-        self.short_label = None
-
-class CompositeRuleBasedValueArgument(ValueSpecification, metaclass=ABCMeta):
-    '''
-    This meta-class has the ability to serve as the abstract base class for ValueSpecifications that can be
-    used for compound primitive data types.
-
-    Base        : ARObject
-    Subclasses  : ApplicationRuleBasedValueSpecification, ApplicationValueSpecification
-    '''
-    def __init__(self):
-        if type(self) == CompositeRuleBasedValueArgument:
-            raise NotImplementedError("CompositeRuleBasedValueArgument is an abstract class.")
-        
-        super().__init__()
-
-class CompositeValueSpecification(ValueSpecification, metaclass=ABCMeta):
-    '''
-    This abstract meta-class acts a base class for ValueSpecifications that have a composite form.
-
-    Base        : ARObject, ValueSpecification
-    Subclasses  : ArrayValueSpecification, RecordValueSpecification
-    '''            
-    def __init__(self):
-        if type(self) == CompositeValueSpecification:
-            raise NotImplementedError("CompositeValueSpecification is an abstract class.")
-        
-        super().__init__()
-
-class ApplicationValueSpecification(CompositeRuleBasedValueArgument):
-    '''
-    This meta-class represents values for DataPrototypes typed by ApplicationDataTypes (this includes in
-    particular compound primitives).
-    For further details refer to ASAM CDF 2.0. This meta-class corresponds to some extent with
-    SW-INSTANCE in ASAM CDF 2.0.
-
-    Base ARObject, CompositeRuleBasedValueArgument, ValueSpecification    
-    '''
-    def __init__(self):
-        super().__init__()
-
-        self.category = None
-        self.sw_Axis_cont = []
-        self.sw_value_cont = None
-
-class RecordValueSpecification(CompositeValueSpecification):
-    '''
-    Specifies the values for a record.
-    
-    Base : ARObject, CompositeValueSpecification, ValueSpecification
-    '''
-    def __init__(self):
-        super().__init__()        
-
-        self._fields = []
-
-    def add_field(self, field: ValueSpecification):
-        self._fields.append(field)
-
-    def get_fields(self) -> List[ValueSpecification]:
-        return self._fields
-
-class TextValueSpecification(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+class AbstractImplementationDataTypeElement(Identifiable):
+    def __init__(self, parent, short_name: str):
+        super().__init__(parent, short_name)
 
-        self.value = None        # type: str
+class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
+    ARRAY_SIZE_SEMANTICS_FIXED_SIZE = "FIXED-SIZE"
+    ARRAY_SIZE_SEMANTICS_VARIABLE_SIZE = "VARIABLE_SIZE"
 
-class NumericalValueSpecification(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, parent, short_name: str):
+        super().__init__(parent, short_name)
 
-        self.value = None        # type: ARFloat  
+        self.arrayImplPolicy = None             # type: ARLiteral
+        self.arraySize = None                   # type: ARNumerical
+        self.arraySizeHandling = None           # type: ARLiteral
+        self.arraySizeSemantics = None          # type: ARLiteral
+        self.isOptional = None                  # type: ARBoolean
+        self.swDataDefProps = None              # type: SwDataDefProps
 
-class ArrayValueSpecification(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+    def getArrayImplPolicy(self):
+        return self.arrayImplPolicy
 
-        self._element = []       # type: List[ValueSpecification]
+    def setArrayImplPolicy(self, value):
+        self.arrayImplPolicy = value
+        return self
 
-    def add_element(self, element: ValueSpecification):
-        self._element.append(element)
+    def getArraySize(self):
+        return self.arraySize
 
-    def get_elements(self) -> List[ValueSpecification]:
-        return self._element
+    def setArraySize(self, value):
+        self.arraySize = value
+        return self
 
-class ConstantSpecification(ARElement):
-    def __init__(self, parent, short_name):
-        super().__init__(parent, short_name)
+    def getArraySizeHandling(self):
+        return self.arraySizeHandling
 
-        self.value_spec = None  # type: ValueSpecification
+    def setArraySizeHandling(self, value):
+        self.arraySizeHandling = value
+        return self
 
-class ConstantReference(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+    def getArraySizeSemantics(self):
+        return self.arraySizeSemantics
 
-        self.constant_ref = None
+    def setArraySizeSemantics(self, value):
+        self.arraySizeSemantics = value
+        return self
 
-class AbstractImplementationDataTypeElement(Identifiable):
-    def __init__(self, parent, short_name: str):
-        super().__init__(parent, short_name)
+    def getIsOptional(self):
+        return self.isOptional
 
-class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
-    ARRAY_SIZE_SEMANTICS_FIXED_SIZE = "FIXED-SIZE"
-    ARRAY_SIZE_SEMANTICS_VARIABLE_SIZE = "VARIABLE_SIZE"
+    def setIsOptional(self, value):
+        self.isOptional = value
+        return self
 
-    def __init__(self, parent, short_name: str):
-        super().__init__(parent, short_name)
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
 
-        self.arraySize = None               # type: int
-        self.array_size_semantics = None      # type: str
-        self.isOptional = None              # type: bool
-        self.sw_data_def_props = None          # type: SwDataDefProps
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
     
     def createImplementationDataTypeElement(self, short_name: str): # type: (...) -> ImplementationDataTypeElement
         if (short_name not in self.elements):
@@ -152,29 +83,27 @@ class ExclusiveArea(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-class InternalBehavior(Identifiable, metaclass=ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == InternalBehavior:
-            raise NotImplementedError("InternalBehavior is an abstract class.")
-        super().__init__(parent, short_name)
-
-        self._dataTypeMappingRefs = []      # type: List[RefType]
-
-    def addDataTypeMappingRef(self, ref: RefType):
-        self._dataTypeMappingRefs.append(ref)
+class IncludedModeDeclarationGroupSet(ARObject):
+    def __init__(self):
+        super().__init__()
 
-    def getDataTypeMappingRefs(self) -> List[RefType]:
-        return self._dataTypeMappingRefs
+        self.mode_declaration_group_refs = []           # type: List[RefType]
+        self.prefix = None                              # type: ARLiteral
 
-    def createExclusiveArea(self, short_name: str) -> ExclusiveArea:
-        if (short_name not in self.elements):
-            event = ExclusiveArea(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+    def addModeDeclarationGroupRef(self, ref: RefType):
+        self.mode_declaration_group_refs.append(ref)
+        return self
 
-    def getExclusiveAreas(self) -> List[ExclusiveArea]:
-        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
+    def getModeDeclarationGroupRefs(self) -> List[RefType]:
+        return self.mode_declaration_group_refs
 
+    def setPrefix(self, prefix: str):
+        self.prefix = prefix
+        return self
+    
+    def getPrefix(self) -> ARLiteral:
+        return self.prefix
+    
 class ModeDeclaration(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -192,24 +121,54 @@ class ExecutableEntity(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == ExecutableEntity:
             raise NotImplementedError("ExecutableEntity is an abstract class.")
+        
         super().__init__(parent, short_name)
     
-        self.activation_reason = None               # *
-        self.minimum_start_interval = None          # type: ARFloat
-        self.reentrancy_level = None                # 
-        self._can_enter_exclusive_area_refs = []    # type: List[RefType]  
+        self.activationReason = None                # *
+        self.minimumStartInterval = None            # type: ARFloat
+        self.reentrancyLevel = None                 # 
+        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]  
+        self.swAddrMethodRef = None                 # type: RefType
+
+    def getActivationReason(self):
+        return self.activationReason
+
+    def setActivationReason(self, value):
+        self.activationReason = value
+        return self
+
+    def getMinimumStartInterval(self):
+        return self.minimumStartInterval
+
+    def setMinimumStartInterval(self, value):
+        self.minimumStartInterval = value
+        return self
+
+    def getReentrancyLevel(self):
+        return self.reentrancyLevel
+
+    def setReentrancyLevel(self, value):
+        self.reentrancyLevel = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
 
     @property
-    def minimum_start_interval_ms(self) -> int:
-        if self.minimum_start_interval is not None:
-            return int(self.minimum_start_interval.getValue() * 1000)
+    def minimumStartIntervalMs(self) -> int:
+        if self.minimumStartInterval is not None:
+            return int(self.minimumStartInterval.getValue() * 1000)
         return None
 
     def addCanEnterExclusiveAreaRef(self, ref: RefType):
-        self._can_enter_exclusive_area_refs.append(ref)
+        self.canEnterExclusiveAreaRefs.append(ref)
 
     def getCanEnterExclusiveAreaRefs(self):
-        return self._can_enter_exclusive_area_refs
+        return self.canEnterExclusiveAreaRefs
     
 class ModeDeclarationGroupPrototype(Identifiable):
     """
@@ -232,21 +191,57 @@ class ModeDeclarationGroupPrototype(Identifiable):
             raise ValueError("Invalid SwCalibrationAccess <%s> of ModeDeclarationGroupPrototype <%s>" % (value, self.short_name))
         self._swCalibrationAccess = value
 
+    def getSwCalibrationAccess(self):
+        return self.swCalibrationAccess
+
+    def setSwCalibrationAccess(self, value):
+        self.swCalibrationAccess = value
+        return self
+
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self
+
 class MemorySection(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
         
         self._alignment = None              # type: ARLiteral
         self.size = None
-        self._options = []                  # type: List[ARLiteral]
+        self.options = []                   # type: List[ARLiteral]
         self.swAddrMethodRef = None         # type: RefType
         self.symbol = None                  # type: ARLiteral
 
-    def addOption(self, option: ARLiteral):
-        self._options.append(option)
+    def getAlignment(self):
+        return self.alignment
 
-    def getOptions(self) -> List[ARLiteral]:
-        return self._options
+    def setAlignment(self, value):
+        self.alignment = value
+        return self
+
+    def getSize(self):
+        return self.size
+
+    def setSize(self, value):
+        self.size = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
 
     @property
     def alignment(self) -> ARLiteral:
@@ -267,7 +262,12 @@ class MemorySection(Identifiable):
                     
             if not match:
                 raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.short_name))
-        
+            
+    def addOption(self, option: ARLiteral):
+        self.options.append(option)
+
+    def getOptions(self) -> List[ARLiteral]:
+        return self.options
 
 class ResourceConsumption(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/communication.py

@@ -1,5 +1,5 @@
 
-from .data_dictionary import SwDataDefProps
+from .m2.msr.data_dictionary.data_def_properties import SwDataDefProps
 from .ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef
 from .ar_object import ARObject
 

armodel/models/data_prototype.py

@@ -2,8 +2,8 @@ from abc import ABCMeta
 
 from .ar_object import ARNumerical
 from .ar_ref import RefType
-from .data_dictionary import SwDataDefProps
-from .common_structure import ValueSpecification
+from .m2.msr.data_dictionary.data_def_properties import SwDataDefProps
+from .m2.autosar_templates.common_structure import ValueSpecification
 from .general_structure import AtpFeature, ARObject
 
 class AtpPrototype(AtpFeature, metaclass = ABCMeta):
@@ -20,8 +20,14 @@ class DataPrototype(AtpPrototype, metaclass = ABCMeta):
 
         super().__init__(parent, short_name)
 
-        self.sw_data_def_props = None   # type: SwDataDefProps
+        self.swDataDefProps = None          # type: SwDataDefProps
 
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
+
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
 class AutosarDataPrototype(DataPrototype, metaclass = ABCMeta):
     def __init__(self, parent:ARObject, short_name: str):
         if type(self) == AutosarDataPrototype:
@@ -29,13 +35,27 @@ class AutosarDataPrototype(DataPrototype, metaclass = ABCMeta):
 
         super().__init__(parent, short_name)
 
-        self.type_tref = None           
+        self.typeTRef = None           
+
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self
 
 class VariableDataPrototype(AutosarDataPrototype):
     def __init__(self, parent:ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.init_value = None      # type: ValueSpecification
+        self.initValue = None      # type: ValueSpecification
+
+    def getInitValue(self):
+        return self.initValue
+
+    def setInitValue(self, value):
+        self.initValue = value
+        return self
 
 class ApplicationCompositeElementDataPrototype(DataPrototype, metaclass = ABCMeta):
     def __init__(self, parent:ARObject, short_name: str):
@@ -46,6 +66,14 @@ class ApplicationCompositeElementDataPrototype(DataPrototype, metaclass = ABCMet
 
         self.typeTRef = None                    # type: RefType
 
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self
+
+
 class ApplicationArrayElement(ApplicationCompositeElementDataPrototype):
     def __init__(self, parent:ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -65,4 +93,11 @@ class ParameterDataPrototype(AutosarDataPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.init_value = None      # type: ValueSpecification
+        self.initValue = None                       # type: ValueSpecification
+
+    def getInitValue(self):
+        return self.initValue
+
+    def setInitValue(self, value):
+        self.initValue = value
+        return self