armodel 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/ServiceMapping.py

@@ -1,5 +1,5 @@
 from typing import List
-from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import NvBlockNeeds, RoleBasedDataAssignment, ServiceNeeds
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagnosticCommunicationManagerNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, NvBlockNeeds, RoleBasedDataAssignment, ServiceNeeds
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Identifier, RefType
 from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import ServiceDependency
@@ -24,7 +24,6 @@ class RoleBasedPortAssignment(ARObject):
         self.role = value
         return self
 
-
 class SwcServiceDependency(ServiceDependency):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -46,12 +45,54 @@ class SwcServiceDependency(ServiceDependency):
 
     def createNvBlockNeeds(self, short_name: str) -> NvBlockNeeds:
         if (short_name not in self.elements):
-            event = NvBlockNeeds(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            needs = NvBlockNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticCommunicationManagerNeeds(self, short_name: str) -> DiagnosticCommunicationManagerNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticCommunicationManagerNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticRoutineNeeds(self, short_name: str) -> DiagnosticRoutineNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticRoutineNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticValueNeeds(self, short_name: str) -> DiagnosticValueNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticValueNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticEventNeeds(self, short_name: str) -> DiagnosticEventNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticEventNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createCryptoServiceNeeds(self, short_name: str) -> CryptoServiceNeeds:
+        if (short_name not in self.elements):
+            needs = CryptoServiceNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
 
     def getNvBlockNeeds(self) -> List[NvBlockNeeds]:
         return sorted(filter(lambda c: isinstance(c, NvBlockNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getDiagnosticCommunicationManagerNeeds(self) -> List[DiagnosticCommunicationManagerNeeds]:
+        return sorted(filter(lambda c: isinstance(c, DiagnosticCommunicationManagerNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getDiagnosticRoutineNeeds(self) -> List[DiagnosticRoutineNeeds]:
+        return sorted(filter(lambda c: isinstance(c, DiagnosticRoutineNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getDiagnosticEventNeeds(self) -> List[DiagnosticEventNeeds]:
+        return sorted(filter(lambda c: isinstance(c, DiagnosticEventNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getCryptoServiceNeeds(self) -> List[CryptoServiceNeeds]:
+        return sorted(filter(lambda c: isinstance(c, CryptoServiceNeeds), self.elements.values()), key=lambda e: e.short_name)
 
     def getServiceNeeds(self) -> List[ServiceNeeds]:
         return sorted(filter(lambda c: isinstance(c, ServiceNeeds), self.elements.values()), key=lambda e: e.short_name)

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/__init__.py

@@ -1,11 +1,12 @@
 from typing import Dict, List
 
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AccessCount import AbstractAccessPoint
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption
 from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype, VariableDataPrototype
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PerInstanceMemory import PerInstanceMemory
-from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import SwcServiceDependency
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType, ARBoolean
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
@@ -27,12 +28,8 @@ class RunnableEntityArgument(ARObject):
     def setSymbol(self, value):
         self.symbol = value
         return self
-
-class AsynchronousServerCallPoint(ServerCallPoint):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-class AsynchronousServerCallResultPoint(ServerCallPoint):
+    
+class AsynchronousServerCallResultPoint(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
@@ -43,7 +40,11 @@ class AsynchronousServerCallResultPoint(ServerCallPoint):
 
     def setAsynchronousServerCallPointRef(self, value):
         self.asynchronousServerCallPointRef = value
-        return self
+        return self    
+
+class AsynchronousServerCallPoint(ServerCallPoint):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
 
 class SynchronousServerCallPoint(ServerCallPoint):
     def __init__(self, parent: ARObject, short_name: str):
@@ -63,6 +64,7 @@ class RunnableEntity(ExecutableEntity):
         super().__init__(parent, short_name)
 
         self.arguments = []                             # type: List[RunnableEntityArgument]
+        self.asynchronousServerCallResultPoints = []    # type: List[AsynchronousServerCallResultPoint]
         self.canBeInvokedConcurrently = None            # type: ARBoolean
         self.dataReadAccesses = {}                      # type: Dict[str, VariableAccess]
         self.dataReceivePointByArguments = {}           # type: Dict[str, VariableAccess]
@@ -92,7 +94,7 @@ class RunnableEntity(ExecutableEntity):
     def addArgument(self, value):
         self.arguments.append(value)
         return self
-
+    
     def getCanBeInvokedConcurrently(self):
         return self.canBeInvokedConcurrently
 
@@ -148,35 +150,48 @@ class RunnableEntity(ExecutableEntity):
     def createParameterAccess(self, short_name: str) -> ParameterAccess:
         if (short_name not in self.elements):
             access = ParameterAccess(self, short_name)
-            self.elements[short_name] = access
-        return self.elements[short_name]
+            self.addElement(access)
+        return self.getElement(short_name)
     
     def createSynchronousServerCallPoint(self, short_name: str) -> SynchronousServerCallPoint:
         if (short_name not in self.serverCallPoints):
-            server_call_point = SynchronousServerCallPoint(self, short_name)
-            self.serverCallPoints[short_name] = server_call_point
-        return self.serverCallPoints[short_name]
+            point = SynchronousServerCallPoint(self, short_name)
+            self.addElement(point)
+        return self.getElement(short_name)
+            #self.serverCallPoints[short_name] = server_call_point
+        #return self.serverCallPoints[short_name]
 
     def createAsynchronousServerCallPoint(self, short_name: str) -> AsynchronousServerCallPoint:
         if (short_name not in self.serverCallPoints):
-            server_call_point = AsynchronousServerCallPoint(self, short_name)
-            self.serverCallPoints[short_name] = server_call_point
-        return self.serverCallPoints[short_name]
+            point = AsynchronousServerCallPoint(self, short_name)
+            self.addElement(point)
+        return self.getElement(short_name)
+            #self.serverCallPoints[short_name] = server_call_point
+        #return self.serverCallPoints[short_name]
+    
+    def createAsynchronousServerCallResultPoint(self, short_name: str) -> AsynchronousServerCallResultPoint:
+        if (short_name not in self.serverCallPoints):
+            point = AsynchronousServerCallResultPoint(self, short_name)
+            self.addElement(point)
+        return self.getElement(short_name)
 
-    def getSynchronousServerCallPoint(self) -> List[ServerCallPoint]:
-        return filter(lambda o: isinstance(o, SynchronousServerCallPoint), self.getServerCallPoints())
+    def getSynchronousServerCallPoint(self) -> List[SynchronousServerCallPoint]:
+        return list(sorted(filter(lambda a: isinstance(a, SynchronousServerCallPoint), self.elements.values()), key= lambda o:o.getShortName()))
     
-    def getAsynchronousServerCallPoint(self) -> List[ServerCallPoint]:
-        return filter(lambda o: isinstance(o, AsynchronousServerCallPoint), self.getServerCallPoints())
+    def getAsynchronousServerCallPoint(self) -> List[AsynchronousServerCallPoint]:
+        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallPoint), self.elements.values()), key= lambda o:o.getShortName()))
+    
+    def getAsynchronousServerCallResultPoints(self) -> List[AsynchronousServerCallResultPoint]:
+        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallResultPoint), self.elements.values()), key= lambda o:o.getShortName()))
 
     def getServerCallPoints(self) -> List[ServerCallPoint]:
-        return sorted(self.serverCallPoints.values(), key=lambda v: v.short_name)
+        return list(sorted(filter(lambda a: isinstance(a, ServerCallPoint), self.elements.values()), key= lambda o:o.getShortName()))
 
     def createInternalTriggeringPoint(self, short_name: str) -> InternalTriggeringPoint:
         if (short_name not in self.elements):
             point = InternalTriggeringPoint(self, short_name)
             self.elements[point.short_name] = point
-        return self.elements[point.short_name]
+        return self.elements[short_name]
 
     def getInternalTriggeringPoints(self) -> List[InternalTriggeringPoint]:
         return filter(lambda o: isinstance(o, InternalTriggeringPoint), self.elements)
@@ -245,38 +260,44 @@ class SwcInternalBehavior(InternalBehavior):
     def createOperationInvokedEvent(self, short_name: str) -> OperationInvokedEvent:
         if (short_name not in self.elements):
             event = OperationInvokedEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createTimingEvent(self, short_name: str) -> TimingEvent:
         if (short_name not in self.elements):
             event = TimingEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createInitEvent(self, short_name: str) -> InitEvent:
         if (short_name not in self.elements):
             event = InitEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
+    
+    def createAsynchronousServerCallReturnsEvent(self, short_name: str) -> AsynchronousServerCallReturnsEvent:
+        if (short_name not in self.elements):
+            event = AsynchronousServerCallReturnsEvent(self, short_name)
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createDataReceivedEvent(self, short_name: str) -> DataReceivedEvent:
         if (short_name not in self.elements):
             event = DataReceivedEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createSwcModeSwitchEvent(self, short_name: str) -> SwcModeSwitchEvent:
         if (short_name not in self.elements):
             event = SwcModeSwitchEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createInternalTriggerOccurredEvent(self, short_name: str) -> InternalTriggerOccurredEvent:
         if (short_name not in self.elements):
             event = InternalTriggerOccurredEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createSwcServiceDependency(self, short_name: str) -> SwcServiceDependency:
         if (short_name not in self.elements):

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/Fibex4Multiplatform.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from .....M2.MSR.Documentation.BlockElements import DocumentationBlock
+from ....MSR.Documentation.TextModel.BlockElements import DocumentationBlock
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARPositiveInteger

armodel/models/M2/MSR/AsamHdo/AdminData.py

@@ -1,3 +1,5 @@
+from ....M2.MSR.Documentation.TextModel.LanguageDataModel import LEnum
+from ....M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguagePlainText
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.MSR.AsamHdo.SpecialData import Sdg
 from typing import List
@@ -6,13 +8,37 @@ class AdminData(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.doc_revision = []
-        self.language = None
-        self.sdg = []
-        self.used_languages = None
+        self.DocRevisions = []                              # type: List[DocRevision]
+        self.language = None                                # type: LEnum
+        self.sdgs = []                                      # type: List[Sdg]
+        self.usedLanguages = None                           # type: MultiLanguagePlainText
 
-    def addSdg(self, sdg: Sdg):
-        self.sdg.append(sdg)
+    def getDocRevisions(self):
+        return self.DocRevisions
 
-    def getSdgs(self) -> List[Sdg]:
-        return self.sdg
+    def setDocRevisions(self, value):
+        self.DocRevisions.append(value)
+        return self
+
+    def getLanguage(self):
+        return self.language
+
+    def setLanguage(self, value):
+        self.language = value
+        return self
+
+    def getSdgs(self):
+        return self.sdgs
+
+    def addSdg(self, value):
+        self.sdgs.append(value)
+        return self
+
+    def getUsedLanguages(self):
+        return self.usedLanguages
+
+    def setUsedLanguages(self, value):
+        self.usedLanguages = value
+        return self
+
+    

armodel/models/M2/MSR/AsamHdo/ComputationMethod.py

@@ -1,7 +1,7 @@
 from typing import List
 from abc import ABCMeta
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, CIdentifier, Identifier, PositiveUnlimitedInteger, String
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Limit
@@ -23,18 +23,35 @@ class CompuConst(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.compu_const_content_type = None    # type: CompuConstContent
+        self.compuConstContentType = None           # type: CompuConstContent
 
+    def getCompuConstContentType(self):
+        return self.compuConstContentType
+
+    def setCompuConstContentType(self, value):
+        self.compuConstContentType = value
+        return self
 
 class Compu(ARObject):
     def __init__(self):
         super().__init__()
 
-        '''required'''
-        self.compu_content = None           # type: CompuContent
+        self.compuContent = None                    # type: CompuContent
+        self.compuDefaultValue = None               # type: CompuConst
+
+    def getCompuContent(self):
+        return self.compuContent
+
+    def setCompuContent(self, value):
+        self.compuContent = value
+        return self
 
-        '''optional'''
-        self.compu_default_value = None     # type: CompuConst
+    def getCompuDefaultValue(self):
+        return self.compuDefaultValue
+
+    def setCompuDefaultValue(self, value):
+        self.compuDefaultValue = value
+        return self
 
 
 class CompuConstContent(ARObject, metaclass=ABCMeta):
@@ -62,6 +79,12 @@ class CompuConstTextContent(CompuConstContent):
 
         self.vt = None
 
+    def getVt(self):
+        return self.vt
+
+    def setVt(self, value):
+        self.vt = value
+        return self
 
 class CompuConstNumericContent(CompuConstContent):
 
@@ -70,6 +93,12 @@ class CompuConstNumericContent(CompuConstContent):
 
         self.v = None
 
+    def getV(self):
+        return self.v
+
+    def setV(self, value):
+        self.v = value
+        return self
 
 class CompuScaleContents(ARObject, metaclass=ABCMeta):
     def __init__(self):
@@ -83,8 +112,14 @@ class CompuScaleConstantContents(CompuScaleContents):
     def __init__(self):
         super().__init__()
 
-        self.compu_const = None     # type: CompuConst
+        self.compuConst = None     # type: CompuConst
+
+    def getCompuConst(self):
+        return self.compuConst
 
+    def setCompuConst(self, value):
+        self.compuConst = value
+        return self
 
 class CompuRationalCoeffs(ARObject):
     '''
@@ -95,9 +130,22 @@ class CompuRationalCoeffs(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.compu_denominator = None   # type: CompuNominatorDenominator
-        self.compu_numerator = None     # type: CompuNominatorDenominator
+        self.compuDenominator = None   # type: CompuNominatorDenominator
+        self.compuNumerator = None     # type: CompuNominatorDenominator
+
+    def getCompuDenominator(self):
+        return self.compuDenominator
+
+    def setCompuDenominator(self, value):
+        self.compuDenominator = value
+        return self
 
+    def getCompuNumerator(self):
+        return self.compuNumerator
+
+    def setCompuNumerator(self, value):
+        self.compuNumerator = value
+        return self
 
 class CompuScaleRationalFormula(CompuScaleContents):
     '''
@@ -106,8 +154,14 @@ class CompuScaleRationalFormula(CompuScaleContents):
     def __init__(self):
         super().__init__()
 
-        self.compu_rational_coeffs = None   # type: CompuRationalCoeffs
+        self.compuRationalCoeffs = None         # type: CompuRationalCoeffs
+
+    def getCompuRationalCoeffs(self):
+        return self.compuRationalCoeffs
 
+    def setCompuRationalCoeffs(self, value):
+        self.compuRationalCoeffs = value
+        return self
 
 class CompuNominatorDenominator(ARObject):
     '''
@@ -131,25 +185,90 @@ class CompuScale(Compu):
     def __init__(self):
         super().__init__()
 
-        self.symbol = None                      # type: ARLiteral
-        self.lowerLimit = None                  # type: Limit
-        self.upperLimit = None                  # type: Limit
-        self.compuInverseValue = None           # type: CompuConst
-        self.compuScaleContents = None          # type: CompuScaleContents
-        self.short_label = None                 # type: ARLiteral
+        self.a2lDisplayText = None                              # type: String
+        self.compuInverseValue = None                           # type: CompuConst
+        self.compuScaleContents = None                          # type: CompuScaleContents
+        self.desc = None                                        # type: MultiLanguageOverviewParagraph
+        self.lowerLimit = None                                  # type: Limit
+        self.mask = None                                        # type: PositiveUnlimitedInteger
+        self.shortLabel = None                                  # type: Identifier
+        self.symbol = None                                      # type: CIdentifier
+        self.upperLimit = None                                  # type: Limit
+
+    def getA2lDisplayText(self):
+        return self.a2lDisplayText
+
+    def setA2lDisplayText(self, value):
+        self.a2lDisplayText = value
+        return self
+
+    def getCompuInverseValue(self):
+        return self.compuInverseValue
+
+    def setCompuInverseValue(self, value):
+        self.compuInverseValue = value
+        return self
+
+    def getCompuScaleContents(self):
+        return self.compuScaleContents
+
+    def setCompuScaleContents(self, value):
+        self.compuScaleContents = value
+        return self
+
+    def getDesc(self):
+        return self.desc
 
+    def setDesc(self, value):
+        self.desc = value
+        return self
+
+    def getLowerLimit(self):
+        return self.lowerLimit
+
+    def setLowerLimit(self, value):
+        self.lowerLimit = value
+        return self
+
+    def getMask(self):
+        return self.mask
+
+    def setMask(self, value):
+        self.mask = value
+        return self
+
+    def getShortLabel(self):
+        return self.shortLabel
+
+    def setShortLabel(self, value):
+        self.shortLabel = value
+        return self
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
+
+    def getUpperLimit(self):
+        return self.upperLimit
+
+    def setUpperLimit(self, value):
+        self.upperLimit = value
+        return self
 
 class CompuScales(CompuContent):
     def __init__(self):
         super().__init__()
 
-        self.compu_scales = []              # type: List[CompuScale]
+        self.compuScales = []              # type: List[CompuScale]
 
     def addCompuScale(self, compu_scale: CompuScale):
-        self.compu_scales.append(compu_scale)
+        self.compuScales.append(compu_scale)
 
     def getCompuScales(self) -> List[CompuScale]:
-        return self.compu_scales
+        return self.compuScales
 
 
 class CompuMethod(ARElement):
@@ -158,7 +277,35 @@ class CompuMethod(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.compu_internal_to_phys = None  # type: Compu
-        self.compu_phys_to_internal = None  # type: Compu
-        self.display_format = None          # type: DisplayFormatString
-        self.unit_ref = None                # type: RefType
+        self.compuInternalToPhys = None     # type: Compu
+        self.compuPhysToInternal = None     # type: Compu
+        self.displayFormat = None           # type: DisplayFormatString
+        self.unitRef = None                 # type: RefType
+
+    def getCompuInternalToPhys(self):
+        return self.compuInternalToPhys
+
+    def setCompuInternalToPhys(self, value):
+        self.compuInternalToPhys = value
+        return self
+
+    def getCompuPhysToInternal(self):
+        return self.compuPhysToInternal
+
+    def setCompuPhysToInternal(self, value):
+        self.compuPhysToInternal = value
+        return self
+
+    def getDisplayFormat(self):
+        return self.displayFormat
+
+    def setDisplayFormat(self, value):
+        self.displayFormat = value
+        return self
+
+    def getUnitRef(self):
+        return self.unitRef
+
+    def setUnitRef(self, value):
+        self.unitRef = value
+        return self

armodel/models/M2/MSR/DataDictionary/AuxillaryObjects.py

@@ -8,7 +8,7 @@ class SwAddrMethod(Identifiable):
         super().__init__(parent, short_name)
 
         self.memoryAllocationKeywordPolicy = None   # type: ARLiteral
-        self.option = []                            # type: List[ARLiteral]
+        self.options = []                            # type: List[ARLiteral]
         self.sectionInitializationPolicy = None     # type: ARLiteral
         self.sectionType = None                     # type: ARLiteral
 
@@ -19,11 +19,11 @@ class SwAddrMethod(Identifiable):
         self.memoryAllocationKeywordPolicy = value
         return self
 
-    def getOption(self):
-        return self.option
+    def getOptions(self):
+        return self.options
 
     def addOption(self, value):
-        self.option.append(value)
+        self.options.append(value)
         return self
 
     def getSectionInitializationPolicy(self):