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

armodel/models/datatype.py

@@ -3,23 +3,9 @@ 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, Identifiable
-from .data_prototype import ApplicationCompositeElementDataPrototype, ApplicationRecordElement
-from .data_dictionary import SwDataDefProps
-from .common_structure import ImplementationDataTypeElement, ModeRequestTypeMap
-
-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 = ""
-
-class SymbolProps(ImplementationProps):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
+from .general_structure import ARElement, ARObject
+from .m2.autosar_templates.sw_component_template.data_type.data_prototypes import ApplicationCompositeElementDataPrototype, ApplicationRecordElement
+from .common_structure import ModeRequestTypeMap
 
 class BaseTypeDefinition(ARObject):
     def __init__(self):
@@ -30,9 +16,9 @@ class BaseTypeDirectDefinition(BaseTypeDefinition):
         super().__init__()
 
         self.base_type_encoding = None
-        self.base_type_size = None                # type: ARNumerical
-        self.byteOrder = None                   # type: str
-        self.mem_alignment = None                # type: ARNumerical
+        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):
@@ -56,16 +42,23 @@ class AtpType(ARElement, metaclass=ABCMeta):
         super().__init__(parent, short_name)
 
 
-class AutosarDataType(AtpType, metaclass=ABCMeta):
+class AutosarDataType(AtpType, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == AutosarDataType:
             raise NotImplementedError("AutosarDataType is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.sw_data_def_props = None   # type: SwDataDefProps
 
+        self.swDataDefProps = None                  # type: SwDataDefProps
+
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
 
-class ApplicationDataType(AutosarDataType, metaclass=ABCMeta):
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
+
+class ApplicationDataType(AutosarDataType, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == ApplicationDataType:
             raise NotImplementedError("ApplicationDataType is an abstract class.")
@@ -140,58 +133,7 @@ class ApplicationRecordDataType(ApplicationCompositeDataType):
     def getApplicationRecordElements(self) -> List[ApplicationRecordElement]:
         return self.record_elements
 
-class AbstractImplementationDataType(AutosarDataType, metaclass=ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == AbstractImplementationDataType:
-            raise NotImplementedError("AbstractImplementationDataType is an abstract class.")
-
-        super().__init__(parent, short_name)
-
-
-class ImplementationDataType(AbstractImplementationDataType):
-    CATEGORY_TYPE_REFERENCE = "TYPE_REFERENCE"
-    CATEGORY_TYPE_VALUE = "VALUE"
-    CATEGORY_TYPE_STRUCTURE = "STRUCTURE"
-    CATEGORY_DATA_REFERENCE = "DATA_REFERENCE"
-    CATEGORY_ARRAY = "ARRAY"
 
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-        
-        self.sub_elements = []      # type: List[str]
-        self.symbol_props = None    # type: ARLiteral
-        self._type_emitter = None    # type: ARLiteral
-
-        self._array_type = None     # ImplementationDataType
-
-    #type:  ImplementationDataTypeElement
-    def createImplementationDataTypeElement(self, short_name: str):
-        self.sub_elements.append(short_name)
-        if (short_name not in self.elements):
-            event = ImplementationDataTypeElement(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
-
-    def getImplementationDataTypeElements(self) -> List[ImplementationDataTypeElement]:
-        elements = []
-        for sub_element in self.sub_elements:
-            elements.append(self.elements[sub_element])
-        return elements
-        # return filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values())
-
-    def getArrayElementType(self) -> str:
-        return self._array_type
-
-    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):

armodel/models/end_to_end_protection.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from .ar_ref import VariableDataPrototypeInSystemInstanceRef
+from .m2.autosar_templates.system_template.instance_refs import VariableDataPrototypeInSystemInstanceRef
 from .ar_object import ARNumerical, ARObject
 from .general_structure import Identifiable
 

armodel/models/fibex/can_communication.py

@@ -1,6 +1,122 @@
-from ..ar_object import ARObject
-from .fibex_core import Frame
+from ..general_structure import Identifiable
+from ..ar_object import ARObject, ARPositiveInteger
+from .fibex_core.core_communication import Frame, FrameTriggering
+
+class RxIdentifierRange(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.lowerCanId = None      # type: ARPositiveInteger
+        self.upperCanId = None      # type: ARPositiveInteger
+
+    def getLowerCanId(self) -> ARPositiveInteger:
+        return self.lowerCanId
+
+    def setLowerCanId(self, value: ARPositiveInteger):
+        self.lowerCanId = value
+        return self
+
+    def getUpperCanId(self) -> ARPositiveInteger:
+        return self.upperCanId
+
+    def setUpperCanId(self, value: ARPositiveInteger):
+        self.upperCanId = value
+        return self
 
 class CanFrame(Frame):
     def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
+        super().__init__(parent, short_name)
+
+class CanFrameTriggering(FrameTriggering):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.absolutelyScheduledTimings = []                    
+        self.canAddressingMode = None
+        self.canFdFrameSupport = None
+        self.canFrameRxBehavior = None
+        self.canFrameTxBehavior = None
+        self.canXlFrameTriggeringProps = None
+        self.identifier = None
+        self.j1939requestable = None
+        self.rxIdentifierRange = None                           # type: RxIdentifierRange
+        self.rxMask = None
+        self.txMask = None
+
+    def getAbsolutelyScheduledTimings(self):
+        return self.absolutelyScheduledTimings
+
+    def setAbsolutelyScheduledTimings(self, value):
+        self.absolutelyScheduledTimings = value
+        return self
+
+    def getCanAddressingMode(self):
+        return self.canAddressingMode
+
+    def setCanAddressingMode(self, value):
+        self.canAddressingMode = value
+        return self
+    
+    def getCanFdFrameSupport(self):
+        return self.canFdFrameSupport
+
+    def setCanFdFrameSupport(self, value):
+        self.canFdFrameSupport = value
+        return self
+
+    def getCanFrameRxBehavior(self):
+        return self.canFrameRxBehavior
+
+    def setCanFrameRxBehavior(self, value):
+        self.canFrameRxBehavior = value
+        return self
+
+    def getCanFrameTxBehavior(self):
+        return self.canFrameTxBehavior
+
+    def setCanFrameTxBehavior(self, value):
+        self.canFrameTxBehavior = value
+        return self
+
+    def getCanXlFrameTriggeringProps(self):
+        return self.canXlFrameTriggeringProps
+
+    def setCanXlFrameTriggeringProps(self, value):
+        self.canXlFrameTriggeringProps = value
+        return self
+
+    def getIdentifier(self):
+        return self.identifier
+
+    def setIdentifier(self, value):
+        self.identifier = value
+        return self
+
+    def getJ1939requestable(self):
+        return self.j1939requestable
+
+    def setJ1939requestable(self, value):
+        self.j1939requestable = value
+        return self
+
+    def getRxIdentifierRange(self) -> RxIdentifierRange:
+        return self.rxIdentifierRange
+
+    def setRxIdentifierRange(self, value: RxIdentifierRange):
+        self.rxIdentifierRange = value
+        return self
+
+    def getRxMask(self):
+        return self.rxMask
+
+    def setRxMask(self, value):
+        self.rxMask = value
+        return self
+
+    def getTxMask(self):
+        return self.txMask
+
+    def setTxMask(self, value):
+        self.txMask = value
+        return self
+

armodel/models/fibex/fibex_4_multiplatform.py

@@ -1,145 +1,138 @@
 from typing import List
 
+from ..m2.msr.documentation.block_elements import DocumentationBlock
 from ..ar_ref import RefType
 from ..ar_object import ARObject, ARPositiveInteger
-from .fibex_core import FibexElement
+from .fibex_core.core_communication 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
+        self.introduction = None            # type: DocumentationBlock
+        self.sourceFrameRef = None          # type: RefType
+        self.targetFrameRef = None          # type: RefType
 
-    @property
-    def introduction(self):
-        return self._introduction
+    def getIntroduction(self):
+        return self.introduction
 
-    @introduction.setter
-    def introduction(self, value):
-        self._introduction = value
+    def setIntroduction(self, value):
+        self.introduction = value
+        return self
 
-    @property
-    def sourceFrameRef(self):
-        return self._source_frame_ref
+    def getSourceFrameRef(self):
+        return self.sourceFrameRef
 
-    @sourceFrameRef.setter
-    def sourceFrameRef(self, value):
-        self._source_frame_ref = value
+    def setSourceFrameRef(self, value):
+        self.sourceFrameRef = value
+        return self
 
-    @property
-    def targetFrameRef(self):
-        return self._target_frame_ref
+    def getTargetFrameRef(self):
+        return self.targetFrameRef
 
-    @targetFrameRef.setter
-    def targetFrameRef(self, value):
-        self._target_frame_ref = value
+    def setTargetFrameRef(self, value):
+        self.targetFrameRef = value
+        return self
 
 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
+        self.introduction = None         # type: DocumentationBlock
+        self.sourceSignalRef = None      # type: RefType
+        self.targetSignalRef = None      # type: RefType
 
-    @property
-    def introduction(self):
-        return self._introduction
+    def getIntroduction(self):
+        return self.introduction
 
-    @introduction.setter
-    def introduction(self, value):
-        self._introduction = value
+    def setIntroduction(self, value):
+        self.introduction = value
+        return self
 
-    @property
-    def sourceSignalRef(self):
-        return self._source_signal_ref
+    def getSourceSignalRef(self):
+        return self.sourceSignalRef
 
-    @sourceSignalRef.setter
-    def sourceSignalRef(self, value):
-        self._source_signal_ref = value
+    def setSourceSignalRef(self, value):
+        self.sourceSignalRef = value
+        return self
 
-    @property
-    def targetSignalRef(self):
-        return self._target_signal_ref
+    def getTargetSignalRef(self):
+        return self.targetSignalRef
 
-    @targetSignalRef.setter
-    def targetSignalRef(self, value):
-        self._target_signal_ref = value
+    def setTargetSignalRef(self, value):
+        self.targetSignalRef = value
+        return self
 
 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
+        self.introduction = None            # type: DocumentationBlock
+        self.pdurTpChunkSize = None         # type: ARPositiveInteger
+        self.sourceIpduRef = None           # type: RefType
+        self.targetIpduRef = None           # type: RefType
 
-    @property
-    def introduction(self):
-        return self._introduction
+    def getIntroduction(self):
+        return self.introduction
 
-    @introduction.setter
-    def introduction(self, value):
-        self._introduction = value
+    def setIntroduction(self, value):
+        self.introduction = value
+        return self
 
-    @property
-    def pdurTpChunkSize(self):
-        return self._pdur_tp_chunk_size
+    def getPdurTpChunkSize(self):
+        return self.pdurTpChunkSize
 
-    @pdurTpChunkSize.setter
-    def pdurTpChunkSize(self, value):
-        self._pdur_tp_chunk_size = value
+    def setPdurTpChunkSize(self, value):
+        self.pdurTpChunkSize = value
+        return self
 
-    @property
-    def sourceIPduRef(self):
-        return self._source_ipdu_ref
+    def getSourceIpduRef(self):
+        return self.sourceIpduRef
 
-    @sourceIPduRef.setter
-    def sourceIPduRef(self, value):
-        self._source_ipdu_ref = value
+    def setSourceIpduRef(self, value):
+        self.sourceIpduRef = value
+        return self
 
-    @property
-    def targetIPduRef(self):
-        return self._target_ipdu_ref
+    def getTargetIpduRef(self):
+        return self.targetIpduRef
 
-    @targetIPduRef.setter
-    def targetIPduRef(self, value):
-        self._target_ipdu_ref = value
+    def setTargetIpduRef(self, value):
+        self.targetIpduRef = value
+        return self
 
 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]
+        self.ecuRef = None                # type: RefType
+        self.frameMappings = []           # type: List[FrameMapping]
+        self.iPduMappings = []            # type: List[IPduMapping]
+        self.signalMappings = []          # type: List[ISignalMapping]
+    
+    def getEcuRef(self):
+        return self.ecuRef
 
-    @property
-    def ecuRef(self) -> RefType:
-        return self._ecu_ref
-
-    @ecuRef.setter
-    def ecuRef(self, value: RefType):
-        self._ecu_ref = value
+    def setEcuRef(self, value):
+        self.ecuRef = value
+        return self
 
     def getFrameMappings(self) -> List[FrameMapping]:
-        return self._frame_mappings
+        return self.frameMappings
 
     def addFrameMapping(self, mapping: FrameMapping):
-        self._frame_mappings.append(mapping)
+        self.frameMappings.append(mapping)
+        return self
 
     def getIPduMappings(self) -> List[FrameMapping]:
-        return self._i_pdu_mappings
+        return self.iPduMappings
 
     def addIPduMappings(self, mapping: FrameMapping):
-        self._i_pdu_mappings.append(mapping)
+        self.iPduMappings.append(mapping)
+        return self
 
     def getSignalMappings(self) -> List[FrameMapping]:
-        return self._signal_mappings
+        return self.signalMappings
 
     def addSignalMapping(self, mapping: FrameMapping):
-        self._signal_mappings.append(mapping)
+        self.signalMappings.append(mapping)
+        return self