armodel 1.7.4__py3-none-any.whl → 1.7.5__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/Fibex4Ethernet/ServiceInstances.py

@@ -1,10 +1,420 @@
+from abc import ABCMeta
 from typing import List
 
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SocketConnection, SocketConnectionBundle
-from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Boolean, PositiveInteger, RefType, TimeValue
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Boolean, PositiveInteger, RefType, String, TimeValue
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 
+
+class TransportProtocolConfiguration(ARObject, metaclass = ABCMeta):
+    def __init__(self):
+        if type(self) == TransportProtocolConfiguration:
+            raise NotImplementedError("TransportProtocolConfiguration is an abstract class.")
+        
+        super().__init__()
+
+class GenericTp(TransportProtocolConfiguration):
+    def __init__(self):
+        super().__init__()
+
+        self.tpAddress = None                                   # type: String
+        self.tpTechnology = None                                # type: String
+
+    def getTpAddress(self):
+        return self.tpAddress
+
+    def setTpAddress(self, value):
+        self.tpAddress = value
+        return self
+
+    def getTpTechnology(self):
+        return self.tpTechnology
+
+    def setTpTechnology(self, value):
+        self.tpTechnology = value
+        return self
+
+
+class TcpUdpConfig(TransportProtocolConfiguration, metaclass = ABCMeta):
+    def __init__(self):
+        if type(self) == TcpUdpConfig:
+            raise NotImplementedError("TcpUdpConfig is an abstract class.")
+        
+        super().__init__()
+
+class TpPort(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.dynamicallyAssigned = None                         # type: Boolean
+        self.portNumber = None                                  # type: PositiveInteger
+
+    def getDynamicallyAssigned(self):
+        return self.dynamicallyAssigned
+
+    def setDynamicallyAssigned(self, value):
+        self.dynamicallyAssigned = value
+        return self
+
+    def getPortNumber(self):
+        return self.portNumber
+
+    def setPortNumber(self, value):
+        self.portNumber = value
+        return self
+
+
+class UdpTp(TcpUdpConfig):
+    def __init__(self):
+        super().__init__()
+
+        self.udpTpPort = None                                   # type: TpPort
+
+    def getUdpTpPort(self):
+        return self.udpTpPort
+
+    def setUdpTpPort(self, value):
+        self.udpTpPort = value
+        return self
+
+
+class TcpTp(TcpUdpConfig):
+    def __init__(self):
+        super().__init__()
+
+        self.keepAliveInterval = None                           # type: TimeValue
+        self.keepAliveProbesMax = None                          # type: PositiveInteger
+        self.keepAlives = None                                  # type: Boolean
+        self.keepAliveTime = None                               # type: TimeValue
+        self.naglesAlgorithm = None                             # type: Boolean
+        self.receiveWindowMin = None                            # type: PositiveInteger
+        self.tcpRetransmissionTimeout = None                    # type: TimeValue
+        self.tcpTpPort = None                                   # type: TpPort
+
+    def getKeepAliveInterval(self):
+        return self.keepAliveInterval
+
+    def setKeepAliveInterval(self, value):
+        self.keepAliveInterval = value
+        return self
+
+    def getKeepAliveProbesMax(self):
+        return self.keepAliveProbesMax
+
+    def setKeepAliveProbesMax(self, value):
+        self.keepAliveProbesMax = value
+        return self
+
+    def getKeepAlives(self):
+        return self.keepAlives
+
+    def setKeepAlives(self, value):
+        self.keepAlives = value
+        return self
+
+    def getKeepAliveTime(self):
+        return self.keepAliveTime
+
+    def setKeepAliveTime(self, value):
+        self.keepAliveTime = value
+        return self
+
+    def getNaglesAlgorithm(self):
+        return self.naglesAlgorithm
+
+    def setNaglesAlgorithm(self, value):
+        self.naglesAlgorithm = value
+        return self
+
+    def getReceiveWindowMin(self):
+        return self.receiveWindowMin
+
+    def setReceiveWindowMin(self, value):
+        self.receiveWindowMin = value
+        return self
+
+    def getTcpRetransmissionTimeout(self):
+        return self.tcpRetransmissionTimeout
+
+    def setTcpRetransmissionTimeout(self, value):
+        self.tcpRetransmissionTimeout = value
+        return self
+
+    def getTcpTpPort(self):
+        return self.tcpTpPort
+
+    def setTcpTpPort(self, value):
+        self.tcpTpPort = value
+        return self
+    
+class AbstractServiceInstance(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AbstractServiceInstance:
+            raise NotImplementedError("AbstractServiceInstance is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        # type: List[TagWithOptionalValue]
+        self.capabilityRecords = []
+        self.majorVersion = None                                # type: PositiveInteger
+        # type: PduActivationRoutingGroup
+        self.methodActivationRoutingGroup = None
+        self.routingGroupRefs = []                              # type: List[RefType]
+
+    def getCapabilityRecords(self):
+        return self.capabilityRecords
+
+    def addCapabilityRecord(self, value):
+        if value is not None:
+            self.capabilityRecords.append(value)
+        return self
+
+    def getMajorVersion(self):
+        return self.majorVersion
+
+    def setMajorVersion(self, value):
+        if value is not None:
+            self.majorVersion = value
+        return self
+
+    def getMethodActivationRoutingGroup(self):
+        return self.methodActivationRoutingGroup
+
+    def setMethodActivationRoutingGroup(self, value):
+        if value is not None:
+            self.methodActivationRoutingGroup = value
+        return self
+
+    def getRoutingGroupRefs(self):
+        return self.routingGroupRefs
+
+    def addRoutingGroupRef(self, value):
+        if value is not None:
+            self.routingGroupRefs.append(value)
+        return self
+    
+class ConsumedEventGroup(Identifiable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.applicationEndpointRef = None                                          # type: RefType
+        self.autoRequire = None                                                     # type: Boolean
+        self.eventGroupIdentifier = None                                            # type: PositiveInteger
+        self.eventMulticastAddressRefs = []                                         # type: List[RefType]
+        self.pduActivationRoutingGroups = []                                        # type: List[PduActivationRoutingGroup]
+        self.priority = None                                                        # type: PositiveInteger
+        self.routingGroupRefs = []                                                  # type: List[RefType]
+        self.sdClientConfig = None                                                  # type: SdClientConfig
+        self.sdClientTimerConfigRef = None                                          # type: RefType
+
+    def getApplicationEndpointRef(self):
+        return self.applicationEndpointRef
+
+    def setApplicationEndpointRef(self, value):
+        if value is not None:
+            self.applicationEndpointRef = value
+        return self
+
+    def getAutoRequire(self):
+        return self.autoRequire
+
+    def setAutoRequire(self, value):
+        if value is not None:
+            self.autoRequire = value
+        return self
+
+    def getEventGroupIdentifier(self):
+        return self.eventGroupIdentifier
+
+    def setEventGroupIdentifier(self, value):
+        if value is not None:
+            self.eventGroupIdentifier = value
+        return self
+
+    def getEventMulticastAddressRefs(self):
+        return self.eventMulticastAddressRefs
+
+    def addEventMulticastAddressRef(self, value):
+        if value is not None:
+            self.eventMulticastAddressRefs.append(value)
+        return self
+
+    def getPduActivationRoutingGroups(self):
+        return self.pduActivationRoutingGroups
+
+    def setPduActivationRoutingGroups(self, value):
+        if value is not None:
+            self.pduActivationRoutingGroups = value
+        return self
+
+    def getPriority(self):
+        return self.priority
+
+    def setPriority(self, value):
+        if value is not None:
+            self.priority = value
+        return self
+
+    def getRoutingGroupRefs(self):
+        return self.routingGroupRefs
+
+    def addRoutingGroupRef(self, value):
+        if value is not None:
+            self.routingGroupRefs.append(value)
+        return self
+
+    def getSdClientConfig(self):
+        return self.sdClientConfig
+
+    def setSdClientConfig(self, value):
+        if value is not None:
+            self.sdClientConfig = value
+        return self
+
+    def getSdClientTimerConfigRef(self):
+        return self.sdClientTimerConfigRef
+
+    def setSdClientTimerConfigRef(self, value):
+        if value is not None:
+            self.sdClientTimerConfigRef = value
+        return self
+
+
+class ConsumedServiceInstance(AbstractServiceInstance):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.allowedServiceProviderRefs = []                                        # type: List[RefType]
+        self.autoRequire = None                                                     # type: Boolean
+        self.blocklistedVersions = []                                               # type: List[SomeipServiceVersion]
+        self.consumedEventGroups = []                                               # type: List[ConsumedEventGroup]
+        self.eventMulticastSubscriptionAddressRef = None                            # type: RefType
+        self.instanceIdentifier = None                                              # type: AnyServiceInstanceId
+        self.localUnicastAddressRefs = []                                           # type: List[RefType]
+        self.minorVersion = None                                                    # type: AnyVersionString
+        self.providedServiceInstanceRef = None                                      # type: RefType
+        self.remoteUnicastAddressRefs = []                                          # type: List[RefType]
+        self.sdClientConfig = None                                                  # type: SdClientConfig
+        self.sdClientTimerConfigRef = None                                          # type: RefType
+        self.serviceIdentifier = None                                               # type: PositiveInteger
+        self.versionDrivenFindBehavior = None                                       # type: ServiceVersionAcceptanceKindEnum     
+
+    def getAllowedServiceProviderRefs(self):
+        return self.allowedServiceProviderRefs
+
+    def setAllowedServiceProviderRefs(self, value):
+        if value is not None:
+            self.allowedServiceProviderRefs = value
+        return self
+
+    def getAutoRequire(self):
+        return self.autoRequire
+
+    def setAutoRequire(self, value):
+        if value is not None:
+            self.autoRequire = value
+        return self
+
+    def getBlocklistedVersions(self):
+        return self.blocklistedVersions
+
+    def setBlocklistedVersions(self, value):
+        if value is not None:
+            self.blocklistedVersions = value
+        return self
+
+    def getConsumedEventGroups(self):
+        return self.consumedEventGroups
+
+    def createConsumedEventGroup(self, short_name: str) -> ConsumedEventGroup:
+        if short_name not in self.elements:
+            group = ConsumedEventGroup(self, short_name)
+            self.addElement(group)
+            self.consumedEventGroups.append(group)
+        return self.getElement(short_name)
+
+    def getEventMulticastSubscriptionAddressRef(self):
+        return self.eventMulticastSubscriptionAddressRef
+
+    def setEventMulticastSubscriptionAddressRef(self, value):
+        if value is not None:
+            self.eventMulticastSubscriptionAddressRef = value
+        return self
+
+    def getInstanceIdentifier(self):
+        return self.instanceIdentifier
+
+    def setInstanceIdentifier(self, value):
+        if value is not None:
+            self.instanceIdentifier = value
+        return self
+
+    def getLocalUnicastAddressRefs(self):
+        return self.localUnicastAddressRefs
+
+    def setLocalUnicastAddressRefs(self, value):
+        if value is not None:
+            self.localUnicastAddressRefs = value
+        return self
+
+    def getMinorVersion(self):
+        return self.minorVersion
+
+    def setMinorVersion(self, value):
+        if value is not None:
+            self.minorVersion = value
+        return self
+
+    def getProvidedServiceInstanceRef(self):
+        return self.providedServiceInstanceRef
+
+    def setProvidedServiceInstanceRef(self, value):
+        if value is not None:
+            self.providedServiceInstanceRef = value
+        return self
+
+    def getRemoteUnicastAddressRefs(self):
+        return self.remoteUnicastAddressRefs
+
+    def setRemoteUnicastAddressRefs(self, value):
+        if value is not None:
+            self.remoteUnicastAddressRefs = value
+        return self
+
+    def getSdClientConfig(self):
+        return self.sdClientConfig
+
+    def setSdClientConfig(self, value):
+        if value is not None:
+            self.sdClientConfig = value
+        return self
+
+    def getSdClientTimerConfigRef(self):
+        return self.sdClientTimerConfigRef
+
+    def setSdClientTimerConfigRef(self, value):
+        if value is not None:
+            self.sdClientTimerConfigRef = value
+        return self
+
+    def getServiceIdentifier(self):
+        return self.serviceIdentifier
+
+    def setServiceIdentifier(self, value):
+        if value is not None:
+            self.serviceIdentifier = value
+        return self
+
+    def getVersionDrivenFindBehavior(self):
+        return self.versionDrivenFindBehavior
+
+    def setVersionDrivenFindBehavior(self, value):
+        if value is not None:
+            self.versionDrivenFindBehavior = value
+        return self
+   
+
 class ApplicationEndpoint(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -20,9 +430,12 @@ class ApplicationEndpoint(Identifiable):
     def getConsumedServiceInstances(self):
         return self.consumedServiceInstances
 
-    def addConsumedServiceInstance(self, value):
-        self.consumedServiceInstances.append(value)
-        return self
+    def createConsumedServiceInstance(self, short_name:str) -> ConsumedServiceInstance:
+        if short_name not in self.elements:
+            instance = ConsumedServiceInstance(self, short_name)
+            self.addElement(instance)
+            self.consumedServiceInstances.append(instance)
+        return self.getElement(short_name)
 
     def getMaxNumberOfConnections(self):
         return self.maxNumberOfConnections
@@ -80,6 +493,7 @@ class SocketAddress(Identifiable):
         self.pathMtuDiscoveryEnabled = None         # type: Boolean
         self.pduCollectionMaxBufferSize = None      # type: PositiveInteger
         self.pduCollectionTimeout = None            # type: TimeValue
+        self.portAddress = None                     # type: PositiveInteger
         self.staticSocketConnections = []           # type: List[StaticSocketConnection]
         self.udpChecksumHandling = None             # type: UdpChecksumCalculationEnum
 
@@ -100,9 +514,10 @@ class SocketAddress(Identifiable):
     def getApplicationEndpoint(self):
         return self.applicationEndpoint
 
-    def setApplicationEndpoint(self, value):
-        self.applicationEndpoint = value
-        return self
+    def createApplicationEndpoint(self, short_name:str) -> ApplicationEndpoint:
+        end_point = ApplicationEndpoint(self, short_name)
+        self.applicationEndpoint = end_point
+        return end_point
 
     def getConnectorRef(self):
         return self.connectorRef
@@ -152,6 +567,13 @@ class SocketAddress(Identifiable):
     def setPduCollectionTimeout(self, value):
         self.pduCollectionTimeout = value
         return self
+    
+    def getPortAddress(self):
+        return self.portAddress
+
+    def setPortAddress(self, value):
+        self.portAddress = value
+        return self
 
     def getStaticSocketConnections(self):
         return self.staticSocketConnections

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/Fibex4Lin/LinCommunication.py

@@ -1,14 +1,15 @@
 
 from abc import ABCMeta
+from typing import List
 
+from ......M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import AREnum, ARNumerical, Integer, RefType, TimeValue
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import Frame, FrameTriggering
 
-class LinFrame(Frame):
-    __metaclass__ = ABCMeta
-
+class LinFrame(Frame, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == LinFrame:
             raise NotImplementedError("LinFrame is an abstract class.")
@@ -30,12 +31,119 @@ class LinFrameTriggering(FrameTriggering):
         return self.identifier
 
     def setIdentifier(self, value):
-        self.identifier = value
+        if value is not None:
+            self.identifier = value
         return self
 
     def getLinChecksum(self):
         return self.linChecksum
 
     def setLinChecksum(self, value):
-        self.linChecksum = value
+        if value is not None:
+            self.linChecksum = value
+        return self
+
+class ResumePosition(AREnum):
+    CONTINUE_AT_IT_POSITION = "continueAtItPosition"
+    START_FROM_BEGINNING = "startFromBeginning"
+
+    def __init__(self):
+        super().__init__((
+            ResumePosition.CONTINUE_AT_IT_POSITION,
+            ResumePosition.START_FROM_BEGINNING
+        ))
+
+class ScheduleTableEntry(ARObject, metaclass = ABCMeta):
+    def __init__(self):
+        
+        if type(self) == ScheduleTableEntry:
+            raise NotImplementedError("ScheduleTableEntry is an abstract class.")
+        
+        super().__init__()
+
+        self.delay = None                                       # type: TimeValue
+        self.introduction = None                                # type: DocumentationBlock
+        self.positionInTable = None                             # type: Integer
+
+    def getDelay(self):
+        return self.delay
+
+    def setDelay(self, value):
+        if value is not None:
+            self.delay = value
+        return self
+
+    def getIntroduction(self):
+        return self.introduction
+
+    def setIntroduction(self, value):
+        if value is not None:
+            self.introduction = value
+        return self
+
+    def getPositionInTable(self):
+        return self.positionInTable
+
+    def setPositionInTable(self, value):
+        if value is not None:
+            self.positionInTable = value
+        return self
+
+class ApplicationEntry(ScheduleTableEntry):
+    def __init__(self):
+        super().__init__()
+
+        self.frameTriggeringRef = None                              # type: RefType
+
+    def getFrameTriggeringRef(self):
+        return self.frameTriggeringRef
+
+    def setFrameTriggeringRef(self, value):
+        if value is not None:
+            self.frameTriggeringRef = value
+        return self
+
+class FreeFormatEntry(ScheduleTableEntry):
+    def __init__(self):
+        super().__init__()
+
+class LinConfigurationEntry(ScheduleTableEntry, metaclass = ABCMeta):
+    def __init__(self):
+
+        if type(self) == LinConfigurationEntry:
+            raise NotImplementedError("LinConfigurationEntry is an abstract class.")
+        
+        super().__init__()
+
+
+class LinScheduleTable(Identifiable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.resumePosition = None                              # type: ResumePosition
+        self.runMode = None                                     # type: RunMode
+        self.tableEntries = []                                  # type: List[ScheduleTableEntry]
+
+    def getResumePosition(self):
+        return self.resumePosition
+
+    def setResumePosition(self, value):
+        if value is not None:
+            self.resumePosition = value
+        return self
+
+    def getRunMode(self):
+        return self.runMode
+
+    def setRunMode(self, value):
+        if value is not None:
+            self.runMode = value
+        return self
+    
+    def getTableEntries(self):
+        return self.tableEntries
+
+    def addTableEntry(self, value):
+        if value is not None:
+            self.tableEntries.append(value)
         return self

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/Fibex4Lin/LinTopology.py

@@ -0,0 +1,94 @@
+from typing import List
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Integer, String, TimeValue
+from .......models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import CommunicationConnector, CommunicationController
+
+
+class LinCommunicationController(CommunicationController):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.protocolVersion = None                                     # type: String
+
+    def getProtocolVersion(self):
+        return self.protocolVersion
+
+    def setProtocolVersion(self, value):
+        if value is not None:
+            self.protocolVersion = value
+        return self
+
+class LinMaster(LinCommunicationController):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        # type: List[LinSlaveConfig]
+        self.linSlaves = []
+        # type: TimeValue
+        self.timeBase = None
+        self.timeBaseJitter = None                                      # type: TimeValue
+
+    def getLinSlaves(self):
+        return self.linSlaves
+
+    def addLinSlaves(self, value):
+        if value is not None:
+            self.linSlaves.append(value)
+        return self
+
+    def getTimeBase(self):
+        return self.timeBase
+
+    def setTimeBase(self, value):
+        if value is not None:
+            self.timeBase = value
+        return self
+
+    def getTimeBaseJitter(self):
+        return self.timeBaseJitter
+
+    def setTimeBaseJitter(self, value):
+        if value is not None:
+            self.timeBaseJitter = value
+        return self
+
+class LinCommunicationConnector(CommunicationConnector):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.initialNad = None                                      # type: Integer
+        self.linConfigurableFrames = []                             # type: List[LinConfigurableFrame]
+        self.linOrderedConfigurableFrames = []                      # type: List[LinOrderedConfigurableFrame]
+        self.scheduleChangeNextTimeBase = None                      # type: Boolean
+
+    def getInitialNad(self):
+        return self.initialNad
+
+    def setInitialNad(self, value):
+        if value is not None:
+            self.initialNad = value
+        return self
+
+    def getLinConfigurableFrames(self):
+        return self.linConfigurableFrames
+
+    def addLinConfigurableFrame(self, value):
+        if value is not None:
+            self.linConfigurableFrames.append(value)
+        return self
+
+    def getLinOrderedConfigurableFrames(self):
+        return self.linOrderedConfigurableFrames
+
+    def addLinOrderedConfigurableFrame(self, value):
+        if value is not None:
+            self.linOrderedConfigurableFrames.append(value)
+        return self
+
+    def getScheduleChangeNextTimeBase(self):
+        return self.scheduleChangeNextTimeBase
+
+    def setScheduleChangeNextTimeBase(self, value):
+        if value is not None:
+            self.scheduleChangeNextTimeBase = value
+        return self