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

armodel/models/datatype.py

@@ -1,7 +1,9 @@
 from abc import ABCMeta
 from typing import List
-from .general_structure import ARElement, Referrable, ARObject
-from .data_prototype import ApplicationArrayElement, ApplicationRecordElement
+
+from .ar_package import Referrable
+from .general_structure import ARElement, ARObject
+from .data_prototype import ApplicationRecordElement
 from .data_dictionary import SwDataDefProps
 from .common_structure import ImplementationDataTypeElement
 
@@ -14,11 +16,23 @@ class ImplementationProps(Referrable, metaclass=ABCMeta):
         super().__init__(parent, short_name)
         self.symbol = ""
 
-
 class SymbolProps(ImplementationProps):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+class BaseTypeDefinition(ARObject):
+    def __init__(self):
+        super().__init__()
+    
+class BaseTypeDirectDefinition(BaseTypeDefinition):
+    def __init__(self):
+        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.native_declaration = None      
 
 class BaseType(ARElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -26,14 +40,13 @@ class BaseType(ARElement, metaclass=ABCMeta):
             raise NotImplementedError("BaseType is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.base_type_definition = None  # Type: BaseTypeDefinition
 
+        self.base_type_definition = BaseTypeDirectDefinition()
 
 class SwBaseType(BaseType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class AtpType(ARElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == AtpType:
@@ -84,12 +97,17 @@ class ApplicationRecordDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.record_elements = []
+
     def createApplicationRecordElement(self, short_name: str) -> ApplicationRecordElement:
         if (short_name not in self.elements):
             record_element = ApplicationRecordElement(self, short_name)
             self.elements[short_name] = record_element
+            self.record_elements.append(self.elements[short_name])
         return self.elements[short_name]
 
+    def getApplicationRecordElements(self) -> List[ApplicationRecordElement]:
+        return self.record_elements
 
 class AbstractImplementationDataType(AutosarDataType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/general_structure.py

@@ -1,13 +1,52 @@
 from abc import ABCMeta
 from typing import List
+
 from .ar_object import ARObject
-from .ar_ref import RefType
 
 
+class Sd(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.value = ""
+
+class Sdg(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.sd = []                        # type: List[Sd]
+        self.sdg_caption = None
+        self.sdg_contents_type = None
+
+    def addSd(self, sd: Sd):
+        self.sd.append(sd)
+
+    def getSds(self) -> List[Sd]:
+        return self.sd
+    
+class AdminData(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.doc_revision = []
+        self.language = None
+        self.sdg = []
+        self.used_languages = None
+
+    def addSdg(self, sdg: Sdg):
+        self.sdg.append(sdg)
+
+    def getSdgs(self) -> List[Sdg]:
+        return self.sdg
+
 class Referrable(ARObject, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == Referrable:
             raise NotImplementedError("Referrable is an abstract class.")
+        ARObject.__init__(self)
+
         self.parent = parent
         self.short_name = short_name
 
@@ -23,11 +62,15 @@ class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
         self.parent = parent
         self.long_name = None
 
-class CollectableElement(metaclass=ABCMeta):
+class CollectableElement(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == CollectableElement:
             raise NotImplementedError("CollectableElement is an abstract class.")
-        self.elements = {}              # type: dict(PackageableElement)
+        self.elements = {}              # type: dict[str, PackageableElement]
+
+    def getTotalElement(self) -> int:
+        #return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements.values())))
+        return len(self.elements.values())
 
     def getElements(self):
         return self.elements.values()
@@ -44,6 +87,7 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
+        self.admin_data = None      # type: AdminData
         self._category = None
         self.desc = None
 
@@ -102,6 +146,7 @@ class ARElement(PackageableElement, metaclass=ABCMeta):
         if type(self) == ARElement:
             raise NotImplementedError("ARElement is an abstract class.")
         super().__init__(parent, short_name)
+        
 
 class AtpStructureElement(AtpFeature, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/global_constraints.py

@@ -0,0 +1,40 @@
+from .ar_ref import RefType
+from .ar_object import ARObject
+from .general_structure import Identifiable, Limit
+
+from typing import List
+
+class InternalConstrs(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.lower_limit = None         # type: Limit
+        self.upper_limit = None         # type: Limit
+
+class PhysConstrs(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.lower_limit = None         # type: Limit
+        self.upper_limit = None         # type: Limit
+        self.unit_ref = None            # type: RefType
+
+class DataConstrRule(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.constr_level = None        # type: int
+        self.internal_constrs = None    # type: InternalConstrs    
+        self.phys_constrs = None        # type: PhysConstrs
+
+class DataConstr(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.data_constr_rule = []    #  type: List[DataConstrRule]
+
+    def addDataConstrRule(self, rule: DataConstrRule):
+        self.data_constr_rule.append(rule)
+
+    def getDataConstrRules(self) -> List[DataConstrRule]:
+        return self.data_constr_rule

armodel/models/m2_msr.py

@@ -1,4 +1,5 @@
 from .general_structure import ARObject, ARElement, Limit
+from .ar_ref import RefType
 from abc import ABCMeta
 from typing import List
 
@@ -6,6 +7,7 @@ class CompuContent(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == CompuContent:
             raise NotImplementedError("CompuContent is an abstract class.")
+        
         super().__init__()
 
 class Compu(ARObject):
@@ -18,28 +20,99 @@ class Compu(ARObject):
         '''optional'''
         self.compu_default_value = None     # type: CompuConst
 
-class CompuConstContent(ARObject):
+class CompuConstContent(ARObject, metaclass=ABCMeta):
+    '''
+    This meta-class represents the fact that the constant value of the computation method can be numerical or textual.
+    Base            : ARObject
+    Subclasses      : CompuConstFormulaContent, CompuConstNumericContent, CompuConstTextContent
+    Aggregated by   : CompuConst.compuConstContentType
+    '''
     def __init__(self):
+        if type(self) == CompuConstContent:
+            raise NotImplementedError("CompuConstContent is an abstract class.")
+        
         super().__init__()
 
 class CompuConstTextContent(CompuConstContent):
+    '''
+    This meta-class represents the textual content of a scale.
+    Base:           ARObject, CompuConstContent
+    Aggregated by:  CompuConst.compuConstContentType
+    '''
     def __init__(self):
         super().__init__()
 
         self.vt = None
 
 class CompuConstNumericContent(CompuConstContent):
+
     def __init__(self):
         super().__init__()
 
         self.v = None
 
 class CompuConst(ARObject):
+    '''
+    This meta-class represents the fact that the value of a computation method scale is constant.
+    Base            : ARObject
+    Aggregated by   : Compu.compuDefaultValue, CompuScale.compuInverseValue, CompuScaleConstantContents.compuCons
+    '''
     def __init__(self):
         super().__init__()
 
         self.compu_const_content_type = None    # type: CompuConstContent
 
+class CompuScaleContents(ARObject, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == CompuScaleContents:
+            raise NotImplementedError("CompuScaleContents is an abstract class.")
+        
+        super().__init__()
+
+class CompuScaleConstantContents(CompuScaleContents):
+    def __init__(self):
+        super().__init__()
+
+        self.compu_const = None     # type: CompuConst
+
+class CompuScaleRationalFormula(CompuScaleContents):
+    '''
+    This meta-class represents the fact that the computation in this scale is represented as rational term.
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.compu_rational_coeffs = None   # type: CompuRationalCoeffs
+
+class CompuNominatorDenominator(ARObject):
+    '''
+    This class represents the ability to express a polynomial either as Nominator or as Denominator.
+    Base          : ARObject
+    Aggregated by : CompuRationalCoeffs.compuDenominator, CompuRationalCoeffs.compuNumerator
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.v = []             # type List[float]
+
+    def add_v(self, v: float):
+        self.v.append(v)
+
+    def get_vs(self) -> List[float]:
+        return self.v
+
+class CompuRationalCoeffs(ARObject):
+    '''
+    This meta-class represents the ability to express a rational function by specifying the coefficients of nominator and denominator.
+    Base            : ARObject
+    Aggregated by   : CompuScaleRationalFormula.compuRationalCoeffs
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.compu_denominator = None   # type: CompuNominatorDenominator
+        self.compu_numerator = None     # type: CompuNominatorDenominator
+
 class CompuScale(Compu):
     def __init__(self):
         super().__init__()
@@ -69,4 +142,5 @@ class CompuMethod(ARElement):
 
         self.compu_internal_to_phys = None  # type: Compu
         self.compu_phys_to_internal = None  # type: Compu
-        self.display_format = None          # type: DisplayFormatString
+        self.display_format = None          # type: DisplayFormatString
+        self.unit_ref = None                # type: RefType

armodel/models/port_prototype.py

@@ -1,6 +1,10 @@
-from typing import List, Dict
+from typing import List
+
+from .data_dictionary import SwDataDefProps
 from .general_structure import ARObject, Identifiable
 from .ar_ref import RefType, TRefType
+from .communication import TransmissionAcknowledgementRequest
+from .common_structure import ValueSpecification
 
 from abc import ABCMeta
 
@@ -68,9 +72,10 @@ class ReceiverComSpec(RPortComSpec):
         super().__init__()
 
         self.data_element_ref = None                # type: RefType
-        self.handle_out_of_range = ""
-        self.uses_end_to_end_protection = False
-
+        self.network_representation = None          # type: SwDataDefProps
+        self.handle_out_of_range = None             # type: HandleOutOfRangeStatusEnum
+        self.uses_end_to_end_protection = False     
+        
 
 class ModeSwitchSenderComSpec(RPortComSpec):
     def __init__(self):
@@ -87,11 +92,12 @@ class SenderComSpec(PPortComSpec):
 
     def __init__(self):
         super().__init__()
-        self.data_element_ref = None  # type: RefType
+        self.data_element_ref = None                # type: RefType
+        self.network_representation = None          # type: SwDataDefProps
         self.handle_out_of_range = ""
+        self.transmission_acknowledge = None        # type: TransmissionAcknowledgementRequest 
         self.uses_end_to_end_protection = False
 
-
 class QueuedSenderComSpec(PPortComSpec):
     def __init__(self):
         super().__init__()
@@ -116,12 +122,12 @@ class NonqueuedReceiverComSpec(ReceiverComSpec):
 
         self.alive_timeout = 0
         self.enable_updated = False
-        self.filter = None                  # type: DataFilter
-        self.handle_data_status = None      # type: boolean
+        self.filter = None                      # type: DataFilter
+        self.handle_data_status = None          # type: bool
         self.handle_never_received = False
         self.handel_timeout_type = ""
-        self.init_value = None               # type: ValueSpecification
-        self.timeout_substitution = None     # type: ValueSpecification
+        self.init_value = None                  # type: ValueSpecification
+        self.timeout_substitution = None        # type: ValueSpecification
 
 class QueuedReceiverComSpec(ReceiverComSpec):
     def __init__(self):
@@ -134,12 +140,11 @@ class PortPrototype(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class AbstractProvidedPortPrototype(PortPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.provided_com_specs = []  # type: Dict[PPortComSpec]
+        self.provided_com_specs = []  # type: List[PPortComSpec]
 
     def _validateRPortComSpec(self, com_spec: PPortComSpec):
         if (isinstance(com_spec, NonqueuedSenderComSpec)):
@@ -160,14 +165,14 @@ class AbstractProvidedPortPrototype(PortPrototype):
         return self.provided_com_specs
 
     def getNonqueuedSenderComSpecs(self) -> List[NonqueuedSenderComSpec]:
-        return list(filter(lambda c: isinstance(c, NonqueuedSenderComSpec), self.provided_com_specs))
+        return filter(lambda c: isinstance(c, NonqueuedSenderComSpec), self.provided_com_specs)
 
 
 class AbstractRequiredPortPrototype(PortPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.required_com_specs = []  # type: Dict[RPortComSpec]
+        self.required_com_specs = []  # type: List[RPortComSpec]
 
     def _validateRPortComSpec(self, com_spec: RPortComSpec):
         if (isinstance(com_spec, ClientComSpec)):
@@ -194,10 +199,10 @@ class AbstractRequiredPortPrototype(PortPrototype):
         return self.required_com_specs
 
     def getClientComSpecs(self) -> List[ClientComSpec]:
-        return list(filter(lambda c: isinstance(c, ClientComSpec), self.required_com_specs))
+        return filter(lambda c: isinstance(c, ClientComSpec), self.required_com_specs)
 
     def getNonqueuedReceiverComSpecs(self) -> List[NonqueuedReceiverComSpec]:
-        return list(filter(lambda c: isinstance(c, NonqueuedReceiverComSpec), self.required_com_specs))
+        return filter(lambda c: isinstance(c, NonqueuedReceiverComSpec), self.required_com_specs)
 
 
 class PPortPrototype(AbstractProvidedPortPrototype):

armodel/models/sw_component.py

@@ -1,9 +1,10 @@
 from typing import List, Dict
 from abc import ABCMeta
 from .general_structure import ARElement, Identifiable, ARObject
-from .ar_ref import AutosarVariableRef, RefType, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, ProvidedPortPrototypeInstanceRef
-from .ar_ref import RequiredPortPrototypeInstanceRef, RVariableInAtomicSwcInstanceRef, RModeInAtomicSwcInstanceRef
-from .port_prototype import RPortPrototype, PPortPrototype
+from .ar_ref import AutosarVariableRef, RefType, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef
+from .ar_ref import PortInCompositionTypeInstanceRef, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
+from .ar_ref import RVariableInAtomicSwcInstanceRef, RModeInAtomicSwcInstanceRef
+from .port_prototype import RPortPrototype, PPortPrototype, PortPrototype
 from .data_prototype import VariableDataPrototype
 from .common_structure import ExecutableEntity, InternalBehavior
 
@@ -11,6 +12,8 @@ class VariableAccess(Identifiable):
     def __init__(self, parent: ARObject, short_name):
         super().__init__(parent, short_name)
         self.accessed_variable_ref = AutosarVariableRef()
+        self.accessed_variable_ref.parent = self
+        self.parent = parent
         self.local_variable_ref = None  # type: RefType
 
 class ExecutableEntity(Identifiable):
@@ -319,23 +322,33 @@ class SwComponentType(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.ports = []     # List[PortPrototype]
+
     def createPPortPrototype(self, short_name: str) -> PPortPrototype:
+        prototype = PPortPrototype(self, short_name)
+        self.ports.append(prototype)
         if (short_name not in self.elements):
-            prototype = PPortPrototype(self, short_name)
             self.elements[short_name] = prototype
         return self.elements[short_name]
 
     def createRPortPrototype(self, short_name) -> RPortPrototype:
+        prototype = RPortPrototype(self, short_name)
+        self.ports.append(prototype)
         if (short_name not in self.elements):
-            prototype = RPortPrototype(self, short_name)
             self.elements[short_name] = prototype
         return self.elements[short_name]
 
     def getPPortPrototypes(self) -> List[PPortPrototype]:
-        return list(filter(lambda c: isinstance(c, PPortPrototype), self.elements.values()))
+        #return list(sorted(filter(lambda c: isinstance(c, PPortPrototype), self.elements.values()), key= lambda o: o.short_name))
+        return list(sorted(filter(lambda c: isinstance(c, PPortPrototype), self.ports), key= lambda o: o.short_name))
 
     def getRPortPrototypes(self) -> List[RPortPrototype]:
-        return list(filter(lambda c: isinstance(c, RPortPrototype), self.elements.values()))
+        #return list(sorted(filter(lambda c: isinstance(c, RPortPrototype), self.elements.values()), key= lambda o: o.short_name))
+        return list(sorted(filter(lambda c: isinstance(c, RPortPrototype), self.ports), key= lambda o: o.short_name))
+    
+    def getPortPrototype(self) -> List[PortPrototype]:
+        #return list(sorted(filter(lambda c: isinstance(c, PortPrototype), self.elements.values()), key= lambda o: o.short_name))
+        return list(sorted(self.ports, key= lambda o: o.short_name))
 
 class AtomicSwComponentType(SwComponentType):
     __metaclass__ = ABCMeta
@@ -395,22 +408,22 @@ class AssemblySwConnector(SwConnector):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.provider_iref = None   # type: ProvidedPortPrototypeInstanceRef
-        self.requester_iref = None  # type: RequiredPortPrototypeInstanceRef
+        self.provider_iref = None   # type: PPortInCompositionInstanceRef
+        self.requester_iref = None  # type: RPortInCompositionInstanceRef
 
 class DelegationSwConnector(SwConnector):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.inner_port_iref = None # type: RefType
-        self.outer_port_iref = None # type: RefType
+        self.inner_port_iref = None # type: PortInCompositionInstanceRef
+        self.outer_port_ref  = None # type: RefType
 
 class PassThroughSwConnector(SwConnector):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.provided_outer_port_iref = None # type: RefType
-        self.required_outer_port_iref = None # type: RefType
+        self.provided_outer_port_ref = None # type: RefType
+        self.required_outer_port_ref = None # type: RefType
 
 class SwComponentPrototype(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -423,18 +436,30 @@ class CompositionSwComponentType(SwComponentType):
         super().__init__(parent, short_name)
 
         self.constant_value_mapping_refs = []   # type: List[RefType]
-        self.data_type_mapping_refs = []        # type: List[RefType]
+        self._data_type_mapping_refs = []       # type: List[RefType]
         self.instantiation_rte_event_props = [] # type: List[InstantiationRTEEventProps]
 
     def createAssemblySwConnector(self, short_name: str) -> AssemblySwConnector:
         if (short_name not in self.elements):
             connector = AssemblySwConnector(self, short_name)
             self.elements[short_name] = connector
-        return self.elements[short_name] 
+        return self.elements[short_name]
+    
+    def createDelegationSwConnector(self, short_name: str) -> DelegationSwConnector:
+        if short_name not in self.elements:
+            connector = DelegationSwConnector(self, short_name)
+            self.elements[short_name] = connector
+        return self.elements[short_name]
 
     def getAssemblySwConnectors(self) -> List[AssemblySwConnector]:
-        return list(filter(lambda e: isinstance(e, AssemblySwConnector), self.elements.values()))
-
+        return list(sorted(filter(lambda e: isinstance(e, AssemblySwConnector), self.elements.values()), key = lambda c: c.short_name))
+    
+    def getDelegationSwConnectors(self) -> List[DelegationSwConnector]:
+        return list(sorted(filter(lambda e: isinstance(e, DelegationSwConnector), self.elements.values()), key = lambda c: c.short_name))
+    
+    def getSwConnectors(self) -> List[SwConnector]:
+        return list(sorted(filter(lambda e: isinstance(e, SwConnector), self.elements.values()), key = lambda c: c.short_name))
+    
     def createSwComponentPrototype(self, short_name: str) -> SwComponentPrototype:
         if (short_name not in self.elements):
             connector = SwComponentPrototype(self, short_name)
@@ -442,4 +467,10 @@ class CompositionSwComponentType(SwComponentType):
         return self.elements[short_name] 
 
     def getSwComponentPrototypes(self) -> List[SwComponentPrototype]:
-        return list(filter(lambda e: isinstance(e, SwComponentPrototype), self.elements.values()))
+        return list(filter(lambda e: isinstance(e, SwComponentPrototype), self.elements.values()))
+    
+    def addDataTypeMapping(self, data_type_mapping_ref: RefType):
+        self._data_type_mapping_refs.append(data_type_mapping_ref)
+
+    def getDataTypeMappings(self) -> List[RefType]:
+        return self._data_type_mapping_refs

armodel/models/unit.py

@@ -0,0 +1,14 @@
+
+from .ar_object import ARLiteral, ARObject
+from .general_structure import ARElement
+
+
+class SingleLanguageUnitNames(ARLiteral):
+    def __init__(self) -> None:
+        super().__init__()
+
+class Unit(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.display_name = None    # type: SingleLanguageUnitNames