armodel 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

armodel/models/data_def_properties.py

@@ -0,0 +1,16 @@
+from typing import List
+from .ar_object import ARFloat, ARLiteral, ARObject
+
+
+class ValueList(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.v = None                                       # type: ARFloat
+        self._vf = []                                       # type: List[ARLiteral]
+
+    def addVf(self, vf: ARLiteral):
+        self._vf.append(vf)
+
+    def getVfs(self) -> List[ARLiteral]:
+        return sorted(self._vf)

armodel/models/data_dictionary.py

@@ -1,17 +1,44 @@
-from .general_structure import ARObject
+from typing import List
+
+from .ar_object import ARFloat, ARLiteral
+from .calibration import SwCalprmAxisSet
+from .annotation import Annotation
+from .general_structure import ARObject, Identifiable
 from .ar_ref import RefType
 
+
+
+class SwDataDefPropsConditional(ARObject):
+    def __init__(self):
+        super().__init__()
+
 class SwDataDefProps(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.base_type_ref = None                   # type: RefType
-        self.compu_method_ref = None                # type: RefType
-        self.data_constr_ref = None                 # type: RefType
-        self.implementation_data_type_ref = None    # type: RefType
-        self.sw_impl_policy = ""
-        self.sw_calibration_access = ""
-        self.sw_pointer_target_props = None         # type: SwPointerTargetProps
+        self._annotations = []                              # type: List[Annotation]
+        self.baseTypeRef = None                             # type: RefType
+        self.compuMethodRef = None                          # type: RefType
+        self.dataConstrRef = None                           # type: RefType
+        self.implementationDataTypeRef = None               # type: RefType
+        self.swImplPolicy = None                            # type: str
+        self.swCalibrationAccess = None                     # type: str
+        self.swCalprmAxisSet = None                         # type: SwCalprmAxisSet
+        self.sw_pointer_target_props = None                    # type: SwPointerTargetProps
+        self.swRecordLayoutRef = None                       # type: RefType
+        self.valueAxisDataTypeRef = None                    # type: RefType
+        self.unitRef = None                                 # type: RefType
+        self.conditional = SwDataDefPropsConditional()      # type: SwDataDefPropsConditional
+
+    def addAnnotation(self, annotation: Annotation):
+        self._annotations.append(annotation)
+
+    def getAnnotations(self) -> List[Annotation]:
+        return self._annotations
+    
+    def setUnitRef(self, ref: RefType):
+        self.unitRef = ref
+        return self
 
 class SwPointerTargetProps(ARObject):
     def __init__(self):
@@ -19,4 +46,14 @@ class SwPointerTargetProps(ARObject):
 
         self.function_pointer_signature = None      # type: RefType
         self.sw_data_def_props = None               # type: SwDataDefProps
-        self.target_category = ""
+        self.target_category = None
+
+class SwAddrMethod(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.memoryAllocationKeywordPolicy = None   # type: MemoryAllocationKeywordPolicyType
+        self.option = []                            # type: str
+        self.sectionInitializationPolicy = None     # type: SectionInitializationPolicyType
+        self.sectionType = None                     # type: MemorySectionType
+    

armodel/models/data_prototype.py

@@ -1,7 +1,10 @@
 from abc import ABCMeta
-from .general_structure import AtpFeature, Identifiable, ARObject
-from .data_dictionary import SwDataDefProps
+
+from .ar_object import ARNumerical
 from .ar_ref import RefType
+from .data_dictionary import SwDataDefProps
+from .common_structure import ValueSpecification
+from .general_structure import AtpFeature, ARObject
 
 class AtpPrototype(AtpFeature, metaclass = ABCMeta):
     def __init__(self, parent:ARObject, short_name: str):
@@ -25,25 +28,41 @@ class AutosarDataPrototype(DataPrototype, metaclass = ABCMeta):
             raise NotImplementedError("AutosarDataPrototype is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.type_tref = RefType()
+
+        self.type_tref = None           
 
 class VariableDataPrototype(AutosarDataPrototype):
     def __init__(self, parent:ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.init_value = None      # type: ValueSpecification
+
 class ApplicationCompositeElementDataPrototype(DataPrototype, metaclass = ABCMeta):
     def __init__(self, parent:ARObject, short_name: str):
         if type(self) == ApplicationCompositeElementDataPrototype:
             raise NotImplementedError("ApplicationCompositeElementDataPrototype is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.type_tref = RefType()
+
+        self.typeTRef = None                    # type: RefType
 
 class ApplicationArrayElement(ApplicationCompositeElementDataPrototype):
     def __init__(self, parent:ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.arraySizeHandling = None               # type: str
+        self.arraySizeSemantics = None              # type: str
+        self.indexDataTypeRef = None                # type: RefType
+        self.maxNumberOfElements = None             # type: ARNumerical
+
 class ApplicationRecordElement(ApplicationCompositeElementDataPrototype):
     def __init__(self, parent:ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.is_optional = None
+
+        self.isOptional = None
+
+class ParameterDataPrototype(AutosarDataPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.init_value = None      # type: ValueSpecification

armodel/models/datatype.py

@@ -1,12 +1,13 @@
 from abc import ABCMeta
 from typing import List
 
+from .ar_object import ARLiteral, ARNumerical
+from .ar_ref import RefType
 from .ar_package import Referrable
-from .general_structure import ARElement, ARObject
-from .data_prototype import ApplicationRecordElement
+from .general_structure import ARElement, ARObject, Identifiable
+from .data_prototype import ApplicationCompositeElementDataPrototype, ApplicationRecordElement
 from .data_dictionary import SwDataDefProps
-from .common_structure import ImplementationDataTypeElement
-
+from .common_structure import ImplementationDataTypeElement, ModeRequestTypeMap
 
 class ImplementationProps(Referrable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -29,9 +30,9 @@ class BaseTypeDirectDefinition(BaseTypeDefinition):
         super().__init__()
 
         self.base_type_encoding = None
-        self.base_type_size = None          # type: int
-        self.byte_order = None              # type: str
-        self.mem_alignment = None
+        self.base_type_size = None                # type: ARNumerical
+        self.byteOrder = None                   # type: str
+        self.mem_alignment = None                # type: ARNumerical
         self.native_declaration = None      
 
 class BaseType(ARElement, metaclass=ABCMeta):
@@ -41,7 +42,7 @@ class BaseType(ARElement, metaclass=ABCMeta):
 
         super().__init__(parent, short_name)
 
-        self.base_type_definition = BaseTypeDirectDefinition()
+        self.baseTypeDefinition = BaseTypeDirectDefinition()
 
 class SwBaseType(BaseType):
     def __init__(self, parent: ARObject, short_name: str):
@@ -84,15 +85,45 @@ class ApplicationCompositeDataType(ApplicationDataType, metaclass=ABCMeta):
 
         super().__init__(parent, short_name)
 
+class ApplicationArrayElement(ApplicationCompositeElementDataPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.arraySizeHandling = None               # type: str
+        self.arraySizeSemantics = None              # type: str
+        self.indexDataTypeRef = None                # type: RefType
+        self.maxNumberOfElements = None             # type: ARNumerical
+
+    def setArraySizeHandling(self, handling: str):
+        self.arraySizeHandling = handling
+        return self
+    
+    def setArraySizeSemantics(self, semantics: str):
+        self.arraySizeSemantics = semantics
+        return self
+    
+    def setIndexDataTypeRef(self, ref: RefType):
+        self.indexDataTypeRef = ref
+        return self
+    
+    def setMaxNumberOfElements(self, number: ARNumerical):
+        self.maxNumberOfElements = number
+        return self
 
 class ApplicationArrayDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.dynamic_array_size_profile = ""
-        self.element = None
-
+        self.dynamic_array_size_profile = None      # type: ARLiteral
+        self.element = None                         # type: ApplicationArrayElement
 
+    def createApplicationArrayElement(self, short_name: str) -> ApplicationArrayElement:
+        if (short_name not in self.elements):
+            array_element = ApplicationArrayElement(self, short_name)
+            self.elements[short_name] = array_element
+            self.element = self.elements[short_name]
+        return self.elements[short_name]
+    
 class ApplicationRecordDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -126,9 +157,10 @@ class ImplementationDataType(AbstractImplementationDataType):
 
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.sub_elements = []      # List(str)
-        self.symbol_props = None    # SymbolProps
-        self.type_emitter = None
+        
+        self.sub_elements = []      # type: List[str]
+        self.symbol_props = None    # type: ARLiteral
+        self._type_emitter = None    # type: ARLiteral
 
         self._array_type = None     # ImplementationDataType
 
@@ -152,21 +184,38 @@ class ImplementationDataType(AbstractImplementationDataType):
 
     def setArrayElementType(self, type: str):
         self._array_type = type
+        return self
+
+    def setTypeEmitter(self, emitter: str):
+        self._type_emitter = emitter
+        return self
+    
+    def getTypeEmitter(self) -> str:
+        return self._type_emitter
 
 
 class DataTypeMap(ARObject):
     def __init__(self):
-        self.application_data_type_ref = None  # type: RefType
-        self.implementation_data_type_ref = None  # type: RefType
-
+        self.application_data_type_ref = None       # type: RefType
+        self.implementation_data_type_ref = None    # type: RefType
 
 class DataTypeMappingSet(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.data_type_maps = []  # type: List[DataTypeMap]
+        
+        self._dataTypeMaps = []                     # type: List[DataTypeMap]
+        self._modeRequestTypeMaps = []              # type: List[ModeRequestTypeMap]
 
     def addDataTypeMap(self, type_map: DataTypeMap):
-        self.data_type_maps.append(type_map)
+        self._dataTypeMaps.append(type_map)
 
     def getDataTypeMaps(self) -> List[DataTypeMap]:
-        return self.data_type_maps
+        return self._dataTypeMaps
+    
+    def addModeRequestTypeMap(self, map: ModeRequestTypeMap):
+        self._modeRequestTypeMaps.append(map)
+
+    def getModeRequestTypeMaps(self) -> List[ModeRequestTypeMap]:
+        return self._modeRequestTypeMaps
+    
+

armodel/models/end_to_end_protection.py

@@ -0,0 +1,67 @@
+from typing import List
+
+from .ar_ref import VariableDataPrototypeInSystemInstanceRef
+from .ar_object import ARNumerical, ARObject
+from .general_structure import Identifiable
+
+
+class EndToEndDescription(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.category = None                # type: str
+        self.counterOffset = None           # type: int
+        self.crcOffset = None               # type: int
+        self.dataIds = []                   # type: List[ARNumerical]
+        self.dataIdMode = None              # type: int
+        self.dataIdNibbleOffset = None      # type: int
+        self.dataLength = None              # type: int
+        self.maxDeltaCounterInit = None     # type: int
+        self.maxNoNewOrRepeatedData = None  # type: int
+        self.syncCounterInit = None         # type: int
+
+    def addDataId(self, id: ARNumerical):
+        self.dataIds.append(id)
+    
+    def getDataIds(self) -> List[ARNumerical]:
+        return sorted(self.dataIds, key = lambda a: a) 
+
+class EndToEndProtectionVariablePrototype(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._receiverIRefs = []            # type: List[VariableDataPrototypeInSystemInstanceRef]
+        self.senderIRef = None             # type: VariableDataPrototypeInSystemInstanceRef
+        self.shortLabel = None              # type: str
+
+    def addReceiverIref(self, iref: VariableDataPrototypeInSystemInstanceRef):
+        self._receiverIRefs.append(iref)
+
+    def getReceiverIrefs(self) -> List[VariableDataPrototypeInSystemInstanceRef]:
+        return self._receiverIRefs
+
+class EndToEndProtection(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.endToEndProfile = None                         # type: EndToEndDescription
+        self.endToEndProtectionVariablePrototype = []       # type: List[EndToEndProtectionVariablePrototype]
+
+    def addEndToEndProtectionVariablePrototype(self, prototype: EndToEndProtectionVariablePrototype):
+        self.endToEndProtectionVariablePrototype.append(prototype)
+
+    def getEndToEndProtectionVariablePrototypes(self) -> List[EndToEndProtectionVariablePrototype]:
+        return self.endToEndProtectionVariablePrototype
+
+class EndToEndProtectionSet(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+    def createEndToEndProtection(self, short_name: str) -> EndToEndProtection:
+        if (short_name not in self.elements):
+            protection = EndToEndProtection(self, short_name)
+            self.elements[short_name] = protection
+        return self.elements[short_name]
+    
+    def getEndToEndProtections(self) -> List[EndToEndProtection]:
+        return sorted(filter(lambda c: isinstance(c, EndToEndProtection), self.elements.values()), key= lambda e: e.short_name)

armodel/models/fibex/can_communication.py

@@ -0,0 +1,6 @@
+from ..ar_object import ARObject
+from .fibex_core import Frame
+
+class CanFrame(Frame):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)

armodel/models/fibex/fibex_4_multiplatform.py

@@ -0,0 +1,145 @@
+from typing import List
+
+from ..ar_ref import RefType
+from ..ar_object import ARObject, ARPositiveInteger
+from .fibex_core import FibexElement
+
+class FrameMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._introduction = None             # type: DocumentationBlock
+        self._source_frame_ref = None         # type: RefType
+        self._target_frame_ref = None         # type: RefType
+
+    @property
+    def introduction(self):
+        return self._introduction
+
+    @introduction.setter
+    def introduction(self, value):
+        self._introduction = value
+
+    @property
+    def sourceFrameRef(self):
+        return self._source_frame_ref
+
+    @sourceFrameRef.setter
+    def sourceFrameRef(self, value):
+        self._source_frame_ref = value
+
+    @property
+    def targetFrameRef(self):
+        return self._target_frame_ref
+
+    @targetFrameRef.setter
+    def targetFrameRef(self, value):
+        self._target_frame_ref = value
+
+class ISignalMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._introduction = None           # type: DocumentationBlock
+        self._source_signal_ref = None      # type: RefType
+        self._target_signal_ref = None      # type: RefType
+
+    @property
+    def introduction(self):
+        return self._introduction
+
+    @introduction.setter
+    def introduction(self, value):
+        self._introduction = value
+
+    @property
+    def sourceSignalRef(self):
+        return self._source_signal_ref
+
+    @sourceSignalRef.setter
+    def sourceSignalRef(self, value):
+        self._source_signal_ref = value
+
+    @property
+    def targetSignalRef(self):
+        return self._target_signal_ref
+
+    @targetSignalRef.setter
+    def targetSignalRef(self, value):
+        self._target_signal_ref = value
+
+class IPduMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._introduction = None           # type: DocumentationBlock
+        self._pdur_tp_chunk_size = None     # type: ARPositiveInteger
+        self._source_ipdu_ref = None        # type: RefType
+        self._target_ipdu_ref = None        # type: RefType
+
+    @property
+    def introduction(self):
+        return self._introduction
+
+    @introduction.setter
+    def introduction(self, value):
+        self._introduction = value
+
+    @property
+    def pdurTpChunkSize(self):
+        return self._pdur_tp_chunk_size
+
+    @pdurTpChunkSize.setter
+    def pdurTpChunkSize(self, value):
+        self._pdur_tp_chunk_size = value
+
+    @property
+    def sourceIPduRef(self):
+        return self._source_ipdu_ref
+
+    @sourceIPduRef.setter
+    def sourceIPduRef(self, value):
+        self._source_ipdu_ref = value
+
+    @property
+    def targetIPduRef(self):
+        return self._target_ipdu_ref
+
+    @targetIPduRef.setter
+    def targetIPduRef(self, value):
+        self._target_ipdu_ref = value
+
+class Gateway(FibexElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._ecu_ref = None                # type: RefType
+        self._frame_mappings = []           # type: List[FrameMapping]
+        self._i_pdu_mappings = []           # type: List[IPduMapping]
+        self._signal_mappings = []          # type: List[ISignalMapping]
+
+    @property
+    def ecuRef(self) -> RefType:
+        return self._ecu_ref
+
+    @ecuRef.setter
+    def ecuRef(self, value: RefType):
+        self._ecu_ref = value
+
+    def getFrameMappings(self) -> List[FrameMapping]:
+        return self._frame_mappings
+
+    def addFrameMapping(self, mapping: FrameMapping):
+        self._frame_mappings.append(mapping)
+
+    def getIPduMappings(self) -> List[FrameMapping]:
+        return self._i_pdu_mappings
+
+    def addIPduMappings(self, mapping: FrameMapping):
+        self._i_pdu_mappings.append(mapping)
+
+    def getSignalMappings(self) -> List[FrameMapping]:
+        return self._signal_mappings
+
+    def addSignalMapping(self, mapping: FrameMapping):
+        self._signal_mappings.append(mapping)