armodel 1.7.1__py3-none-any.whl → 1.7.3__py3-none-any.whl

armodel/cli/arxml_dump_cli.py

@@ -52,8 +52,8 @@ def show_type(indent: int, data_type: ImplementationDataType):
 def show_data_type_mapping(indent: int, mapping_set: DataTypeMappingSet):
     print("%s- Data Mapping Set <%s>:" % (" " * indent, mapping_set.short_name))
     for mapping in mapping_set.getDataTypeMaps():
-        print("%s- appl: %s" % (" " * (indent + 2), mapping.application_data_type_ref.value))
-        print("%s- impl: %s" % (" " * (indent + 4), mapping.implementation_data_type_ref.value))
+        print("%s- appl: %s" % (" " * (indent + 2), mapping.applicationDataTypeRef.value))
+        print("%s- impl: %s" % (" " * (indent + 4), mapping.implementationDataTypeRef.value))
 
 def show_behavior(indent:int, behavior: SwcInternalBehavior):
     print("%s-Behavior: %s" % (" " * indent, behavior.short_name))
@@ -116,7 +116,7 @@ def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntryRef", starts_on_event.implementedEntryRef.value))
         implemented_entry = document.find(starts_on_event.implementedEntryRef.value) # type: BswModuleEntry
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntry", implemented_entry.short_name))
-        print("%s-%s: %d" % (" " * (indent + 6), "Service Id", implemented_entry.service_id))
+        print("%s-%s: %d" % (" " * (indent + 6), "Service Id", implemented_entry.serviceId))
 
 def show_bsw_module_description(indent: int, description: BswModuleDescription):
     print("%s-%s" % (" " * indent, description.short_name))

armodel/models/M2/AUTOSARTemplates/AutosarTopLevelStructure.py

@@ -111,10 +111,10 @@ class AbstractAUTOSAR(CollectableElement):
             raise ValueError("%s is not ImplementationDataType." % data_type)
             
     def addDataTypeMap(self, data_type_map: DataTypeMap):
-        if (data_type_map.application_data_type_ref is None) or (data_type_map.implementation_data_type_ref is None):
+        if (data_type_map.applicationDataTypeRef is None) or (data_type_map.implementationDataTypeRef is None):
             return
-        self._appl_impl_type_maps[data_type_map.application_data_type_ref.value] = data_type_map.implementation_data_type_ref.value
-        self._impl_appl_type_maps[data_type_map.implementation_data_type_ref.value] = data_type_map.application_data_type_ref.value
+        self._appl_impl_type_maps[data_type_map.applicationDataTypeRef.value] = data_type_map.implementationDataTypeRef.value
+        self._impl_appl_type_maps[data_type_map.implementationDataTypeRef.value] = data_type_map.applicationDataTypeRef.value
 
     def convertToImplementationDataType(self, appl_data_type: str) -> ImplementationDataType:
         if (appl_data_type not in self._appl_impl_type_maps.keys()):

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswBehavior.py

@@ -1,7 +1,7 @@
 from ....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARFloat, ARNumerical
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, AREnum, ARFloat, ARNumerical, String, TimeValue
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from ....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
@@ -128,29 +128,40 @@ class BswCalledEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class BswSchedulableEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+class BswInterruptCategory(AREnum):
+    CAT1 = "cat1"
+    CAT2 = "cat2"
+
+    def __init__(self):
+        super().__init__((
+            BswInterruptCategory.CAT1,
+            BswInterruptCategory.CAT2,
+        ))    
 
 class BswInterruptEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._interrupt_category = ""
-        self.interrupt_source = ""
+        self.interruptCategory = None               # type: BswInterruptCategory
+        self.interruptSource = None                 # type: String
 
-    @property
-    def interrupt_category(self) -> str:
-        return self._interrupt_category
+    def getInterruptCategory(self):
+        return self.interruptCategory
 
-    @interrupt_category.setter
-    def interrupt_category(self, value):
-        if (value.upper() not in ("CAT1", "CAT2")):
-            raise ValueError("Invalid interrupt category <%s> of %s" % (value, self.short_name))
-        self._interrupt_category = value
+    def setInterruptCategory(self, value):
+        self.interruptCategory = value
+        return self
+
+    def getInterruptSource(self):
+        return self.interruptSource
 
+    def setInterruptSource(self, value):
+        self.interruptSource = value
+        return self
 
 class BswEvent(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -158,43 +169,50 @@ class BswEvent(Identifiable, metaclass=ABCMeta):
             raise NotImplementedError("BswEvent is an abstract class.")
         super().__init__(parent, short_name)
 
-        self.startsOnEventRef = None                    # type: RefType 
+        self.startsOnEventRef = None                    # type: RefType
 
+    def getStartsOnEventRef(self):
+        return self.startsOnEventRef
+
+    def setStartsOnEventRef(self, value):
+        self.startsOnEventRef = value
+        return self
 
 class BswOperationInvokedEvent(BswEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class BswScheduleEvent(BswEvent, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == BswScheduleEvent:
             raise NotImplementedError("BswScheduleEvent is an abstract class.")
         super().__init__(parent, short_name)
 
-
 class BswModeSwitchEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._activation = ""
+        self.activation = None
 
-    @property
-    def activation(self) -> str:
-        return self._activation
-
-    @activation.setter
-    def activation(self, value: str):
-        if (value not in ()):
-            raise ValueError("Invalid activation <%s> of BswModeSwitchEvent <%s>" % (value, self.short_name))
-        self._activation = value
+    def getActivation(self):
+        return self.activation
 
+    def setActivation(self, value):
+        self.activation = value
+        return self
 
 class BswTimingEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.period = None          # type: ARFloat
+        self.period = None          # type: TimeValue
+
+    def getPeriod(self):
+        return self.period
+
+    def setPeriod(self, value):
+        self.period = value
+        return self
 
     @property
     def periodMs(self) -> int:
@@ -207,22 +225,39 @@ class BswDataReceivedEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.data_ref = None                # type: RefType
+        self.dataRef = None                # type: RefType
 
+    def getDataRef(self):
+        return self.dataRef
+
+    def setDataRef(self, value):
+        self.dataRef = value
+        return self
 
 class BswInternalTriggerOccurredEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.event_source_ref = None                # type: RefType
+        self.eventSourceRef = None                # type: RefType
 
+    def getEventSourceRef(self):
+        return self.eventSourceRef
 
+    def setEventSourceRef(self, value):
+        self.eventSourceRef = value
+        return self
 class BswModeSwitchAckRequest(ARObject):
     def __init__(self):
         super().__init__()
 
         self.timeout = None                         # type: ARFloat
 
+    def getTimeout(self):
+        return self.timeout
+
+    def setTimeout(self, value):
+        self.timeout = value
+        return self
 
 class BswModeSenderPolicy(ARObject):
     def __init__(self):
@@ -271,23 +306,33 @@ class BswInternalBehavior(InternalBehavior):
 
     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)
-        return self.elements[short_name]
+            entity = BswCalledEntity(self, short_name)
+            self.addElement(entity)
+            self.entities.append(entity)
+        return self.getElement(short_name)
 
     def getBswCalledEntities(self) -> List[BswCalledEntity]:
         return list(filter(lambda a: isinstance(a, BswCalledEntity), self.elements.values()))
 
     def createBswSchedulableEntity(self, short_name: str) -> BswSchedulableEntity:
         if (short_name not in self.elements):
-            event = BswSchedulableEntity(self, short_name)
-            self.elements[short_name] = event
-            self.entities.append(event)
-        return self.elements[short_name]
+            entity = BswSchedulableEntity(self, short_name)
+            self.addElement(entity)
+            self.entities.append(entity)
+        return self.getElement(short_name)
 
     def getBswSchedulableEntities(self) -> List[BswSchedulableEntity]:
         return list(filter(lambda a: isinstance(a, BswSchedulableEntity), self.elements.values()))
+    
+    def createBswInterruptEntity(self, short_name: str) -> BswInterruptEntity:
+        if (short_name not in self.elements):
+            entity = BswInterruptEntity(self, short_name)
+            self.addElement(entity)
+            self.entities.append(entity)
+        return self.getElement(short_name)
+
+    def getBswInterruptEntities(self) -> List[BswInterruptEntity]:
+        return list(filter(lambda a: isinstance(a, BswInterruptEntity), self.elements.values()))
 
     def getBswModuleEntities(self) -> List[BswModuleEntity]:
         return list(filter(lambda a: isinstance(a, BswModuleEntity), self.elements.values()))

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswInterfaces.py

@@ -1,52 +1,126 @@
+from typing import List
+
+from ....M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARLiteral, ARNumerical
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, Boolean, Identifier, NameToken
 
 class BswModuleEntry(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.service_id = None                      # type: ARNumerical
-        self.is_reentrant = None                    # type: ARBoolean
-        self.is_synchronous = None                  # type: ARBoolean
-        self.call_type = None                       # type: ARLiteral
-        self._execution_context = None              # type: ARLiteral
-        self._sw_service_impl_policy = None         # type: ARLiteral
+        self.arguments = []                         # type: List[SwServiceArg]
+        self.bswEntryKind = None                    # type: BswEntryKindEnum
+        self.callType = None                        # type: BswCallType
+        self.executionContext = None                # type: BswExecutionContext
+        self.functionPrototypeEmitter = None        # type: NameToken
+        self.isReentrant = None                     # type: Boolean
+        self.isSynchronous = None                   # type: Boolean
+        self.returnType = None                      # type: SwServiceArg
+        self.role = None                            # type: Identifier
+        self.serviceId = None                       # type: ARNumerical
+        self.swServiceImplPolicy = None             # type: SwServiceImplPolicyEnum
+
+    def getArguments(self):
+        return self.arguments
+
+    def createArgument(self, short_name: str) -> SwServiceArg:
+        if (short_name not in self.elements):
+            arg = SwServiceArg(self, short_name)
+            self.addElement(arg)
+            self.arguments.append(arg)
+        return self.getElement(short_name)
+
+    def getBswEntryKind(self):
+        return self.bswEntryKind
+
+    def setBswEntryKind(self, value):
+        self.bswEntryKind = value
+        return self
 
-    @property
-    def execution_context(self):
-        return self._execution_context
+    def getCallType(self):
+        return self.callType
 
-    @execution_context.setter
-    def execution_context(self, value):
+    def setCallType(self, value):
+        self.callType = value
+        return self
+
+    def getExecutionContext(self):
+        return self.executionContext
+
+    def setExecutionContext(self, value):
         if value.upper() not in ("HOOK", "INTERRUPT-CAT-1", "INTERRUPT-CAT-2", "TASK", "UNSPECIFIED"):
             raise ValueError("Invalid execution context <%s> of BswModuleEntry <%s>" % (value, self.short_name))
-        self._execution_context = value
+        self.executionContext = value
+        return self
+
+    def getFunctionPrototypeEmitter(self):
+        return self.functionPrototypeEmitter
+
+    def setFunctionPrototypeEmitter(self, value):
+        self.functionPrototypeEmitter = value
+        return self
+
+    def getIsReentrant(self):
+        return self.isReentrant
 
-    @property
-    def sw_service_impl_policy(self):
-        return self._sw_service_impl_policy
+    def setIsReentrant(self, value):
+        self.isReentrant = value
+        return self
 
-    @sw_service_impl_policy.setter
-    def sw_service_impl_policy(self, value):
+    def getIsSynchronous(self):
+        return self.isSynchronous
+
+    def setIsSynchronous(self, value):
+        self.isSynchronous = value
+        return self
+
+    def getReturnType(self):
+        return self.returnType
+
+    def setReturnType(self, value):
+        self.returnType = value
+        return self
+
+    def getRole(self):
+        return self.role
+
+    def setRole(self, value):
+        self.role = value
+        return self
+
+    def getServiceId(self):
+        return self.serviceId
+
+    def setServiceId(self, value):
+        self.serviceId = value
+        return self
+
+    def getSwServiceImplPolicy(self):
+        return self.swServiceImplPolicy
+
+    def setSwServiceImplPolicy(self, value):
         if value.upper() not in ("INLINE", "INLINE-CONDITIONAL", "MACRO", "STANDARD"):
             raise ValueError("Invalid SwServiceImplPolicy <%s> of BswModuleEntry <%s>" % (value, self.short_name))
-        self._sw_service_impl_policy = value
+        self.swServiceImplPolicy = value
+        return self
 
     def __str__(self) -> str:
         result = []
+
         result.append("short_name             : %s" % self.short_name)
-        if self.service_id != None:
-            result.append("service_id             : %d" % self.service_id)
-        if self.is_reentrant != None:
-            result.append("is_reentrant           : %s" % self.is_reentrant)
-        if self.is_synchronous != None:
-            result.append("is_synchronous         : %s" % self.is_synchronous)
-        if self.call_type != None:
-            result.append("call_type              : %s" % self.call_type)
+        if self.serviceId != None:
+            result.append("service_id             : %d" % self.serviceId)
+        if self.isReentrant != None:
+            result.append("is_reentrant           : %s" % self.isReentrant)
+        if self.isSynchronous != None:
+            result.append("is_synchronous         : %s" % self.isSynchronous)
+        if self.callType != None:
+            result.append("call_type              : %s" % self.callType)
         if self.execution_context != None:
-            result.append("execution_context      : %s" % self.execution_context)
+            result.append("execution_context      : %s" % self.executionContext)
         if self.sw_service_impl_policy != None:
-            result.append("sw_service_impl_policy : %s" % self.sw_service_impl_policy)
+            result.append("sw_service_impl_policy : %s" % self.swServiceImplPolicy)
 
-        return "\n".join(result)
+        return "\n".join(result)
+    

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswOverview.py

@@ -19,30 +19,26 @@ class BswModuleDescription(ARElement):
         super().__init__(parent, short_name)
 
         # MODULE-ID
-        self.module_id = None                           # type: ARPositiveInteger           
+        self.moduleId = None                           # type: ARPositiveInteger
+
         # PROVIDED-ENTRYS
-        self._implementedEntryRefs = []                 # type: List[RefType]
+        self.implementedEntryRefs = []                 # type: List[RefType]
 
         self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
         self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
+    
+    def getModuleId(self):
+        return self.moduleId
+
+    def setModuleId(self, value):
+        self.moduleId = value
+        return self
 
     def addImplementedEntry(self, entry_ref: RefType):
-        self._implementedEntryRefs.append(entry_ref)
+        self.implementedEntryRefs.append(entry_ref)
 
     def getImplementedEntries(self) -> List[RefType]:
-        return self._implementedEntryRefs
-
-    #@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)
+        return self.implementedEntryRefs
 
     def createProvidedModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
         if (short_name not in self.elements):

armodel/models/M2/AUTOSARTemplates/CommonStructure/FlatMap.py

@@ -0,0 +1,70 @@
+from typing import List
+from ....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Identifier
+from ....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable
+
+class FlatInstanceDescriptor(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self.ecuExtractReferenceIRef = None                     # type: AnyInstanceRef
+        self.role = None                                        # type: Identifier
+        self.rtePluginProps = None                              # type: RtePluginProps
+        self.swDataDefProps = None                              # type: SwDataDefProps
+        self.upstreamReferenceIRef = None                       # type: AnyInstanceRef
+
+    def getEcuExtractReferenceIRef(self):
+        return self.ecuExtractReferenceIRef
+
+    def setEcuExtractReferenceIRef(self, value):
+        self.ecuExtractReferenceIRef = value
+        return self
+
+    def getRole(self):
+        return self.role
+
+    def setRole(self, value):
+        self.role = value
+        return self
+
+    def getRtePluginProps(self):
+        return self.rtePluginProps
+
+    def setRtePluginProps(self, value):
+        self.rtePluginProps = value
+        return self
+
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
+
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
+
+    def getUpstreamReferenceIRef(self):
+        return self.upstreamReferenceIRef
+
+    def setUpstreamReferenceIRef(self, value):
+        self.upstreamReferenceIRef = value
+        return self
+
+
+class FlatMap(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.instances = []                                 # type: List[FlatInstanceDescriptor]
+
+    def getInstances(self):
+        return list(sorted(filter(lambda a: isinstance(a, FlatInstanceDescriptor), self.elements.values()), key= lambda o:o.short_name))
+
+    def createFlatInstanceDescriptor(self, short_name: str):
+        if (short_name not in self.elements):
+            element = FlatInstanceDescriptor(self, short_name)
+            self.addElement(element)
+            self.instances.append(element)
+        return self.getElement(short_name)
+
+

armodel/models/M2/AUTOSARTemplates/CommonStructure/Implementation.py

@@ -1,6 +1,6 @@
 from abc import ABCMeta
 from typing import List
-from ....M2.AUTOSARTemplates.CommonStructure import ResourceConsumption
+from ....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, PackageableElement, Referrable
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType, ARLiteral, String
@@ -28,17 +28,18 @@ class Code(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
+        self.artifactDescriptors = []          # type: List[AutosarEngineeringObject]
         self.callbackHeaderRefs = []            # type: List[RefType]
 
     def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
-        self._artifactDescriptors.append(desc)
+        self.artifactDescriptors.append(desc)
+        return self
 
     def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
         if (category == ""):
-            return self._artifactDescriptors
+            return self.artifactDescriptors
         else:
-            return list(filter(lambda a: a.getCategory().getText() == category, self._artifactDescriptors))
+            return list(filter(lambda a: a.getCategory().getText() == category, self.artifactDescriptors))
 
 class Compiler(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -199,10 +200,12 @@ class Implementation(PackageableElement, metaclass = ABCMeta):
     def getResourceConsumption(self):
         return self.resourceConsumption
 
-    def setResourceConsumption(self, consumption: ResourceConsumption):
-        self.elements[consumption.short_name] = consumption
-        self.resourceConsumption = consumption
-        return self
+    def createResourceConsumption(self, short_name: str) -> ResourceConsumption:
+        if (short_name not in self.elements):
+            consumption = ResourceConsumption(self, short_name)
+            self.addElement(consumption)
+            self.resourceConsumption = consumption
+        return self.getElement(short_name)
 
     def getSwcBswMappingRef(self):
         return self.swcBswMappingRef

armodel/models/M2/AUTOSARTemplates/CommonStructure/ImplementationDataTypes.py

@@ -1,7 +1,7 @@
 from abc import ABCMeta
 from typing import List
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, Boolean, String
 from ....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
@@ -96,19 +96,30 @@ class ImplementationDataType(AbstractImplementationDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.arrayImplPolicy = None
-        self.arraySize = None
-        self.arraySizeHandling = None                   # type: ARLiteral
-        self.arraySizeSemantics = None                  # type: ARLiteral
+        self.dynamicArraySizeProfile = None             # type: String
+        self.isStructWithOptionalElement = None         # type: Boolean
         
         self.subElements = []                           # type: List[str]
         self.symbolProps = None                         # type: SymbolProps
-        self._type_emitter = None                       # type: ARLiteral
+        self.typeEmitter = None                       # type: ARLiteral
 
-        self._array_type = None         # ImplementationDataType
-        self._struct_type = None        # ImplementationDataType
+        #self._array_type = None         # ImplementationDataType
+        #self._struct_type = None        # ImplementationDataType
+
+    def getDynamicArraySizeProfile(self):
+        return self.dynamicArraySizeProfile
+
+    def setDynamicArraySizeProfile(self, value):
+        self.dynamicArraySizeProfile = value
+        return self
+
+    def getIsStructWithOptionalElement(self):
+        return self.isStructWithOptionalElement
+
+    def setIsStructWithOptionalElement(self, value):
+        self.isStructWithOptionalElement = value
+        return self
 
-    
     def createImplementationDataTypeElement(self, short_name: str) -> ImplementationDataTypeElement:     
         self.subElements.append(short_name)
         if (short_name not in self.elements):
@@ -131,11 +142,11 @@ class ImplementationDataType(AbstractImplementationDataType):
         return self
 
     def setTypeEmitter(self, emitter: str):
-        self._type_emitter = emitter
+        self.typeEmitter = emitter
         return self
     
     def getTypeEmitter(self) -> str:
-        return self._type_emitter
+        return self.typeEmitter
     
     def setStructElementType(self, type: str):
         self._struct_type = type