armodel 1.6.1__py3-none-any.whl → 1.6.3__py3-none-any.whl

armodel/models/{bsw_module_template.py → M2/AUTOSARTemplates/BswModuleTemplate/BswBehavior.py}

@@ -1,13 +1,52 @@
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
+from ..CommonStructure.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARFloat, ARNumerical
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..CommonStructure.InternalBehavior import ReentrancyLevelEnum
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import TimeValue
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from ..CommonStructure.InternalBehavior import ExecutableEntity
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Referrable
 from abc import ABCMeta
-from typing import Dict, List
+from typing import List
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 
-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, IncludedModeDeclarationGroupSet, ModeDeclarationGroupPrototype, Identifiable
-from .ar_ref import RefType
+class BswModuleCallPoint(Referrable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.contextLimitationRefs = []                 # type: List[RefType]
 
-class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
+    def getContextLimitationRefs(self):
+        return self.contextLimitationRefs
+
+    def addContextLimitationRef(self, value):
+        self.contextLimitationRefs.append(value)
+        return self
+    
+class BswVariableAccess(Referrable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.accessedVariableRef = None                     # type: RefType
+        self.contextLimitationRefs = []                     # type: List[RefType]
+
+    def getAccessedVariableRef(self):
+        return self.accessedVariableRef
+
+    def setAccessedVariableRef(self, value):
+        self.accessedVariableRef = value
+        return self
+
+    def getContextLimitationRefs(self):
+        return self.contextLimitationRefs
+
+    def addContextLimitationRef(self, value):
+        self.contextLimitationRefs.append(value)
+        return self
+
+class BswModuleEntity(ExecutableEntity, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == BswModuleEntity:
             raise NotImplementedError("BswModuleEntity is an abstract class.")
@@ -15,23 +54,49 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
 
         self.accessedModeGroupRefs = []                 # type: List[RefType]
         self.activationPointRefs = []                   # type: List[RefType]
+        self.callPoints = []                            # type: List[BswModuleCallPoint]
+        self.dataReceivePoints = []                     # type: List[BswVariableAccess]
+        self.dataSendPoints = []                        # type: List[BswVariableAccess]
         self.implementedEntryRef = None                 # type: RefType
+        self.issuedTriggerRefs = []                     # type: List[RefType]
         self.managedModeGroupRefs = []                  # type: List[RefType]
-
+        self.schedulerNamePrefixRef = None              # type: List[RefType]
+    
     def getAccessedModeGroupRefs(self):
         return self.accessedModeGroupRefs
 
-    def addAccessedModeGroupRefs(self, value):
+    def addAccessedModeGroupRef(self, value):
         self.accessedModeGroupRefs.append(value)
         return self
 
     def getActivationPointRefs(self):
         return self.activationPointRefs
 
-    def addActivationPointRefs(self, value):
+    def addActivationPointRef(self, value):
         self.activationPointRefs.append(value)
         return self
 
+    def getCallPoints(self):
+        return self.callPoints
+
+    def addCallPoint(self, value):
+        self.callPoints.append(value)
+        return self
+
+    def getDataReceivePoint(self):
+        return self.dataReceivePoints
+
+    def addDataReceivePoint(self, value):
+        self.dataReceivePoints.append(value)
+        return self
+
+    def getDataSendPoints(self):
+        return self.dataSendPoints
+
+    def addDataSendPoint(self, value):
+        self.dataSendPoints.append(value)
+        return self
+
     def getImplementedEntryRef(self):
         return self.implementedEntryRef
 
@@ -39,20 +104,38 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
         self.implementedEntryRef = value
         return self
 
-    def addManagedModeGroupRef(self, ref: RefType):
-        self.managedModeGroupRefs.append(ref)
+    def getIssuedTriggerRefs(self):
+        return self.issuedTriggerRefs
+
+    def addIssuedTriggerRefs(self, value):
+        self.issuedTriggerRefs(value)
+        return self
 
-    def getManagedModeGroupRefs(self) -> List[RefType]:
+    def getManagedModeGroupRefs(self):
         return self.managedModeGroupRefs
 
+    def addManagedModeGroupRef(self, value):
+        self.managedModeGroupRefs = value
+        return self
+
+    def getSchedulerNamePrefixRef(self):
+        return self.schedulerNamePrefixRef
+
+    def setSchedulerNamePrefixRef(self, value):
+        self.schedulerNamePrefixRef = value
+        return self
+
+
 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 BswInterruptEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -70,6 +153,7 @@ class BswInterruptEntity(BswModuleEntity):
             raise ValueError("Invalid interrupt category <%s> of %s" % (value, self.short_name))
         self._interrupt_category = value
 
+
 class BswEvent(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == BswEvent:
@@ -78,16 +162,19 @@ class BswEvent(Identifiable, metaclass=ABCMeta):
 
         self.startsOnEventRef = None                    # type: RefType 
 
+
 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)
@@ -104,10 +191,11 @@ class BswModeSwitchEvent(BswScheduleEvent):
             raise ValueError("Invalid activation <%s> of BswModeSwitchEvent <%s>" % (value, self.short_name))
         self._activation = value
 
+
 class BswTimingEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        
+
         self.period = None          # type: ARFloat
 
     @property
@@ -116,24 +204,28 @@ class BswTimingEvent(BswScheduleEvent):
             return int(self.period.value * 1000)
         return None
 
+
 class BswDataReceivedEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self.data_ref = None                # type: RefType
 
+
 class BswInternalTriggerOccurredEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self.event_source_ref = None                # type: RefType
 
+
 class BswModeSwitchAckRequest(ARObject):
     def __init__(self):
         super().__init__()
 
         self.timeout = None                         # type: ARFloat
 
+
 class BswModeSenderPolicy(ARObject):
     def __init__(self):
         super().__init__()
@@ -149,7 +241,7 @@ class BswModeSenderPolicy(ARObject):
 
     def getProvidedModeGroupRef(self) -> RefType:
         return self._provided_mode_group_ref
-    
+
     def setQueueLength(self, length: any):
         if isinstance(length, ARNumerical):
             self._queue_length = length
@@ -158,10 +250,11 @@ class BswModeSenderPolicy(ARObject):
             self._queue_length.setValue(length)
         else:
             raise ValueError("Unsupported type <%s>" % type(length))
-        
+
     def getQueueLength(self) -> ARNumerical:
         return self._queue_length
 
+
 class BswInternalBehavior(InternalBehavior):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -197,7 +290,7 @@ class BswInternalBehavior(InternalBehavior):
 
     def getBswSchedulableEntities(self) -> List[BswSchedulableEntity]:
         return list(filter(lambda a: isinstance(a, BswSchedulableEntity), self.elements.values()))
-    
+
     def getBswModuleEntities(self) -> List[BswModuleEntity]:
         return list(filter(lambda a: isinstance(a, BswModuleEntity), self.elements.values()))
 
@@ -210,7 +303,7 @@ class BswInternalBehavior(InternalBehavior):
 
     def getBswModeSwitchEvents(self) -> List[BswModeSwitchEvent]:
         return list(filter(lambda a: isinstance(a, BswModeSwitchEvent), self.elements.values()))
-    
+
     def createBswTimingEvent(self, short_name: str) -> BswTimingEvent:
         if (short_name not in self.elements):
             event = BswTimingEvent(self, short_name)
@@ -240,138 +333,20 @@ class BswInternalBehavior(InternalBehavior):
 
     def getBswInternalTriggerOccurredEvents(self) -> List[BswInternalTriggerOccurredEvent]:
         return list(filter(lambda a: isinstance(a, BswInternalTriggerOccurredEvent), self.elements.values()))
-    
+
     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)
 
     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
-        BSW module.
-        
-        **attributes**:
-         module_id              : MODULE-ID  
-         implemented_entry_refs : PROVIDED-ENTRYS
-    '''
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-        # MODULE-ID
-        self.module_id = None                           # type: ARPositiveInteger           
-        # PROVIDED-ENTRYS
-        self._implementedEntryRefs = []                 # type: List[RefType]
-
-        self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
-        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
-
-    def addImplementedEntry(self, entry_ref: RefType):
-        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)
-
-    def createProvidedModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
-        if (short_name not in self.elements):
-            prototype = ModeDeclarationGroupPrototype(self, short_name)
-            self.elements[short_name] = prototype
-            self.providedModeGroups[short_name] = prototype
-        return self.elements[short_name]
-
-    def getProvidedModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return sorted(self.providedModeGroups.values(), key=lambda v: v.short_name) 
-
-    def createRequiredModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
-        if (short_name not in self.elements):
-            prototype = ModeDeclarationGroupPrototype(self, short_name)
-            self.elements[short_name] = prototype
-            self.requiredModeGroups[short_name] = property
-        return self.elements[short_name]
-
-    def getRequiredModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return sorted(self.requiredModeGroups.values(), key=lambda v: v.short_name) 
-
-    def createBswInternalBehavior(self, short_name: str) -> BswInternalBehavior:
-        '''
-            Create the INTERNAL-BEHAVIORS tag
-        '''
-        if (short_name not in self.elements):
-            prototype = BswInternalBehavior(self, short_name)
-            self.elements[short_name] = prototype
-        return self.elements[short_name]
-
-    def getBswInternalBehaviors(self) -> List[BswInternalBehavior]:
-        return list(filter(lambda a: isinstance(a, BswInternalBehavior), self.elements.values()))
-
-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
-
-    @property
-    def execution_context(self):
-        return self._execution_context
-
-    @execution_context.setter
-    def execution_context(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
-
-    @property
-    def sw_service_impl_policy(self):
-        return self._sw_service_impl_policy
-
-    @sw_service_impl_policy.setter
-    def sw_service_impl_policy(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
-
-    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.execution_context != None:
-            result.append("execution_context      : %s" % self.execution_context)
-        if self.sw_service_impl_policy != None:
-            result.append("sw_service_impl_policy : %s" % self.sw_service_impl_policy)
-            
-        return "\n".join(result)
+    

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

@@ -0,0 +1,21 @@
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+from ..CommonStructure.Implementation import Implementation
+from typing import List
+
+class BswImplementation(Implementation):
+    def __init__(self, parent: ARObject, short_name: str) -> None:
+        super().__init__(parent, short_name)
+
+        self.ar_release_version = None                      # type: ARLiteral
+        self.behavior_ref = None                            # type: RefType
+        self.preconfiguredConfigurationRef = []             # type: List[RefType]
+        self.recommendedConfigurationRef = []               # type: List[RefType]
+        self.vendorApiInfix = None                          # type: str
+        self._vendorSpecificModuleDefRef = []               # type: List[RefType]
+
+    def addVendorSpecificModuleDefRef(self, ref: RefType):
+        self._vendorSpecificModuleDefRef.append(ref)
+
+    def getVendorSpecificModuleDefRefs(self):
+        return self._vendorSpecificModuleDefRef

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

@@ -0,0 +1,52 @@
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARLiteral, ARNumerical
+
+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
+
+    @property
+    def execution_context(self):
+        return self._execution_context
+
+    @execution_context.setter
+    def execution_context(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
+
+    @property
+    def sw_service_impl_policy(self):
+        return self._sw_service_impl_policy
+
+    @sw_service_impl_policy.setter
+    def sw_service_impl_policy(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
+
+    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.execution_context != None:
+            result.append("execution_context      : %s" % self.execution_context)
+        if self.sw_service_impl_policy != None:
+            result.append("sw_service_impl_policy : %s" % self.sw_service_impl_policy)
+
+        return "\n".join(result)

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

@@ -0,0 +1,78 @@
+from ..BswModuleTemplate.BswBehavior import BswInternalBehavior
+from ..CommonStructure.ModeDeclaration import ModeDeclarationGroupPrototype
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARPositiveInteger, RefType
+from typing import Dict, List
+
+
+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
+        BSW module.
+
+        **attributes**:
+         module_id              : MODULE-ID  
+         implemented_entry_refs : PROVIDED-ENTRYS
+    '''
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        # MODULE-ID
+        self.module_id = None                           # type: ARPositiveInteger           
+        # PROVIDED-ENTRYS
+        self._implementedEntryRefs = []                 # type: List[RefType]
+
+        self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
+        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
+
+    def addImplementedEntry(self, entry_ref: RefType):
+        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)
+
+    def createProvidedModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
+        if (short_name not in self.elements):
+            prototype = ModeDeclarationGroupPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.providedModeGroups[short_name] = prototype
+        return self.elements[short_name]
+
+    def getProvidedModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
+        return sorted(self.providedModeGroups.values(), key=lambda v: v.short_name)
+
+    def createRequiredModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
+        if (short_name not in self.elements):
+            prototype = ModeDeclarationGroupPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.requiredModeGroups[short_name] = property
+        return self.elements[short_name]
+
+    def getRequiredModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
+        return sorted(self.requiredModeGroups.values(), key=lambda v: v.short_name)
+
+    def createBswInternalBehavior(self, short_name: str) -> BswInternalBehavior:
+        '''
+            Create the INTERNAL-BEHAVIORS tag
+        '''
+        if (short_name not in self.elements):
+            prototype = BswInternalBehavior(self, short_name)
+            self.elements[short_name] = prototype
+        return self.elements[short_name]
+
+    def getBswInternalBehaviors(self) -> List[BswInternalBehavior]:
+        return list(filter(lambda a: isinstance(a, BswInternalBehavior), self.elements.values()))

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

@@ -0,0 +1 @@
+from . import *

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

@@ -0,0 +1,81 @@
+from abc import ABCMeta
+from typing import List
+from .ResourceConsumption import ResourceConsumption
+from ..GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, PackageableElement, Referrable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType, ARLiteral
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+
+class ImplementationProps(Referrable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == ImplementationProps:
+            raise NotImplementedError("ImplementationProps is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.symbol = None                          # type: ARLiteral
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
+
+
+class Code(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
+        self.callbackHeaderRefs = []            # type: List[RefType]
+
+    def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
+        self._artifactDescriptors.append(desc)
+
+    def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
+        if (category == ""):
+            return self._artifactDescriptors
+        else:
+            return list(filter(lambda a: a.getCategory().getText() == category, self._artifactDescriptors))
+
+
+class Implementation(PackageableElement, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str) -> None:
+        if type(self) == Implementation:
+            raise NotImplementedError("Implementation is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.build_action_manifest_ref = None               # type: RefType
+        self.compilers = None
+        self.generated_artifacts = None
+        self.hw_element_refs = []                           # type: List[RefType]
+        self.linker = []
+        self.mc_support = None
+        self.programming_language = None                    # type: ARLiteral
+        self.required_artifacts = []
+        self.required_generator_tools = []
+        self.resource_consumption = None                    # type: ResourceConsumption
+        self.sw_version = ""                                # type: ARLiteral
+        self.swc_bsw_mapping_ref = None                     # type: RefType
+        self.used_code_generator = None                     # type: ARLiteral
+        self.vendor_id = 0                                  # type: ARNumerical
+
+    def createCodeDescriptor(self, short_name: str) -> Code:
+        if (short_name not in self.elements):
+            sw_component = Code(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
+
+    def getCodeDescriptors(self)-> List[Code]:
+        return list(filter(lambda a : isinstance(a, Code), self.elements.values()))
+
+    def setResourceConsumption(self, consumption: ResourceConsumption):
+        self.elements[consumption.short_name] = consumption
+        self.resource_consumption = consumption
+        return self
+
+    def getResourceConsumption(self) -> ResourceConsumption:
+        return self.resource_consumption