armodel 1.6.2__py3-none-any.whl → 1.6.4__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswInterfaces.py

@@ -0,0 +1,52 @@
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARLiteral, ARNumerical
+
+class BswModuleEntry(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.service_id = None                      # type: ARNumerical
+        self.is_reentrant = None                    # type: ARBoolean
+        self.is_synchronous = None                  # type: ARBoolean
+        self.call_type = None                       # type: ARLiteral
+        self._execution_context = None              # type: ARLiteral
+        self._sw_service_impl_policy = None         # type: ARLiteral
+
+    @property
+    def execution_context(self):
+        return self._execution_context
+
+    @execution_context.setter
+    def execution_context(self, value):
+        if value.upper() not in ("HOOK", "INTERRUPT-CAT-1", "INTERRUPT-CAT-2", "TASK", "UNSPECIFIED"):
+            raise ValueError("Invalid execution context <%s> of BswModuleEntry <%s>" % (value, self.short_name))
+        self._execution_context = value
+
+    @property
+    def sw_service_impl_policy(self):
+        return self._sw_service_impl_policy
+
+    @sw_service_impl_policy.setter
+    def sw_service_impl_policy(self, value):
+        if value.upper() not in ("INLINE", "INLINE-CONDITIONAL", "MACRO", "STANDARD"):
+            raise ValueError("Invalid SwServiceImplPolicy <%s> of BswModuleEntry <%s>" % (value, self.short_name))
+        self._sw_service_impl_policy = value
+
+    def __str__(self) -> str:
+        result = []
+        result.append("short_name             : %s" % self.short_name)
+        if self.service_id != None:
+            result.append("service_id             : %d" % self.service_id)
+        if self.is_reentrant != None:
+            result.append("is_reentrant           : %s" % self.is_reentrant)
+        if self.is_synchronous != None:
+            result.append("is_synchronous         : %s" % self.is_synchronous)
+        if self.call_type != None:
+            result.append("call_type              : %s" % self.call_type)
+        if self.execution_context != None:
+            result.append("execution_context      : %s" % self.execution_context)
+        if self.sw_service_impl_policy != None:
+            result.append("sw_service_impl_policy : %s" % self.sw_service_impl_policy)
+
+        return "\n".join(result)

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswOverview.py

@@ -0,0 +1,77 @@
+from ....M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior
+from ....M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroupPrototype
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARPositiveInteger, RefType
+from typing import Dict, List
+
+class BswModuleDescription(ARElement):
+    '''
+        Root element for the description of a single BSW module or BSW cluster. In case it
+        describes a BSW module, the short name of this element equals the name of the
+        BSW module.
+
+        **attributes**:
+         module_id              : MODULE-ID  
+         implemented_entry_refs : PROVIDED-ENTRYS
+    '''
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        # MODULE-ID
+        self.module_id = None                           # type: ARPositiveInteger           
+        # PROVIDED-ENTRYS
+        self._implementedEntryRefs = []                 # type: List[RefType]
+
+        self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
+        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
+
+    def addImplementedEntry(self, entry_ref: RefType):
+        self._implementedEntryRefs.append(entry_ref)
+
+    def getImplementedEntries(self) -> List[RefType]:
+        return self._implementedEntryRefs
+
+    #@property
+    #def category(self) -> str:
+    #    return ARElement.getCategory(self)
+
+    #@category.setter
+    #def category(self, value:str):
+    #    if value is None:
+    #        return
+    #    if value not in ("BSW_MODULE", "BSW_CLUSTER", "LIBRARY"):
+    #        raise ValueError("Invalid category <%s> of BswModuleDescription <%s>" % (value, self.short_name))
+    #    ARElement.setCategory(self, value)
+
+    def createProvidedModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
+        if (short_name not in self.elements):
+            prototype = ModeDeclarationGroupPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.providedModeGroups[short_name] = prototype
+        return self.elements[short_name]
+
+    def getProvidedModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
+        return sorted(self.providedModeGroups.values(), key=lambda v: v.short_name)
+
+    def createRequiredModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
+        if (short_name not in self.elements):
+            prototype = ModeDeclarationGroupPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.requiredModeGroups[short_name] = property
+        return self.elements[short_name]
+
+    def getRequiredModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
+        return sorted(self.requiredModeGroups.values(), key=lambda v: v.short_name)
+
+    def createBswInternalBehavior(self, short_name: str) -> BswInternalBehavior:
+        '''
+            Create the INTERNAL-BEHAVIORS tag
+        '''
+        if (short_name not in self.elements):
+            prototype = BswInternalBehavior(self, short_name)
+            self.elements[short_name] = prototype
+        return self.elements[short_name]
+
+    def getBswInternalBehaviors(self) -> List[BswInternalBehavior]:
+        return list(filter(lambda a: isinstance(a, BswInternalBehavior), self.elements.values()))

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/__init__.py

@@ -0,0 +1,4 @@
+from .BswBehavior import *
+from .BswImplementation import *
+from .BswInterfaces import *
+from .BswOverview import *

armodel/models/M2/AUTOSARTemplates/CommonStructure/Implementation.py

@@ -0,0 +1,238 @@
+from abc import ABCMeta
+from typing import List
+from ....M2.AUTOSARTemplates.CommonStructure import ResourceConsumption
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, PackageableElement, Referrable
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType, ARLiteral, String
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+
+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 = None                          # type: ARLiteral
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
+
+
+class Code(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
+        self.callbackHeaderRefs = []            # type: List[RefType]
+
+    def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
+        self._artifactDescriptors.append(desc)
+
+    def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
+        if (category == ""):
+            return self._artifactDescriptors
+        else:
+            return list(filter(lambda a: a.getCategory().getText() == category, self._artifactDescriptors))
+
+class Compiler(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.name = None                                    # type: String
+        self.options = None                                 # type: String
+        self.vendor = None                                  # type: String
+        self.version = None                                 # type: String
+
+    def getName(self):
+        return self.name
+
+    def setName(self, value):
+        self.name = value
+        return self
+
+    def getOptions(self):
+        return self.options
+
+    def setOptions(self, value):
+        self.options = value
+        return self
+
+    def getVendor(self):
+        return self.vendor
+
+    def setVendor(self, value):
+        self.vendor = value
+        return self
+
+    def getVersion(self):
+        return self.version
+
+    def setVersion(self, value):
+        self.version = value
+        return self
+    
+class DependencyOnArtifact(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        # type: AutosarEngineeringObject
+        self.artifactDescriptor = None
+        self.usage = None                                   # type: DependencyUsageEnum
+
+    def getArtifactDescriptor(self):
+        return self.artifactDescriptor
+
+    def setArtifactDescriptor(self, value):
+        self.artifactDescriptor = value
+        return self
+
+    def getUsage(self):
+        return self.usage
+
+    def setUsage(self, value):
+        self.usage = value
+        return self
+
+
+class Implementation(PackageableElement, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == Implementation:
+            raise NotImplementedError("Implementation is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.buildActionManifestRef = None                  # type: RefType
+        self.codeDescriptors = []                           # type: List[Code]
+        self.compilers = []                                 # type: List[Compiler]
+        self.generatedArtifacts = []                        # type: List[DependencyOnArtifact]
+        self.hwElementRefs = []                             # type: List[RefType]
+        self.linkers = []                                   # type: List[Linker]
+        self.mcSupport = None
+        self.programmingLanguage = None                     # type: ProgramminglanguageEnum
+        self.requiredArtifacts = []                         # type: List[DependencyOnArtifact]
+        self.requiredGeneratorTools = []                    # type: List[DependencyOnArtifact]
+        self.resourceConsumption = None                     # type: ResourceConsumption
+        self.swcBswMappingRef = None                        # type: RefType
+        self.swVersion = []                                 # type: RevisionLabelString
+        self.usedCodeGenerator = None                       # type: String
+        self.vendorId = 0                                   # type: PositiveInteger
+
+    def getBuildActionManifestRef(self):
+        return self.buildActionManifestRef
+
+    def setBuildActionManifestRef(self, value):
+        self.buildActionManifestRef = value
+        return self
+
+    def getCodeDescriptors(self)-> List[Code]:
+        return list(filter(lambda a : isinstance(a, Code), self.elements.values()))
+
+    def createCodeDescriptor(self, short_name: str) -> Code:
+        if (short_name not in self.elements):
+            code_descriptor = Code(self, short_name)
+            self.addElement(code_descriptor)
+            self.codeDescriptors.append(code_descriptor)
+        return self.getElement(short_name)
+
+    def getCompilers(self):
+        return self.compilers
+
+    def setCompilers(self, value):
+        self.compilers = value
+        return self
+
+    def getGeneratedArtifacts(self):
+        return self.generatedArtifacts
+
+    def setGeneratedArtifacts(self, value):
+        self.generatedArtifacts = value
+        return self
+
+    def getHwElementRefs(self):
+        return self.hwElementRefs
+
+    def setHwElementRefs(self, value):
+        self.hwElementRefs = value
+        return self
+
+    def getLinkers(self):
+        return self.linkers
+
+    def setLinkers(self, value):
+        self.linkers = value
+        return self
+
+    def getMcSupport(self):
+        return self.mcSupport
+
+    def setMcSupport(self, value):
+        self.mcSupport = value
+        return self
+
+    def getProgrammingLanguage(self):
+        return self.programmingLanguage
+
+    def setProgrammingLanguage(self, value):
+        self.programmingLanguage = value
+        return self
+
+    def getRequiredArtifacts(self):
+        return self.requiredArtifacts
+
+    def setRequiredArtifacts(self, value):
+        self.requiredArtifacts = value
+        return self
+
+    def getRequiredGeneratorTools(self):
+        return self.requiredGeneratorTools
+
+    def setRequiredGeneratorTools(self, value):
+        self.requiredGeneratorTools = value
+        return self
+
+    def getResourceConsumption(self):
+        return self.resourceConsumption
+
+    def setResourceConsumption(self, consumption: ResourceConsumption):
+        self.elements[consumption.short_name] = consumption
+        self.resourceConsumption = consumption
+        return self
+
+    def getSwcBswMappingRef(self):
+        return self.swcBswMappingRef
+
+    def setSwcBswMappingRef(self, value):
+        self.swcBswMappingRef = value
+        return self
+
+    def getSwVersion(self):
+        return self.swVersion
+
+    def setSwVersion(self, value):
+        self.swVersion = value
+        return self
+
+    def getUsedCodeGenerator(self):
+        return self.usedCodeGenerator
+
+    def setUsedCodeGenerator(self, value):
+        self.usedCodeGenerator = value
+        return self
+
+    def getVendorId(self):
+        return self.vendorId
+
+    def setVendorId(self, value):
+        self.vendorId = value
+        return self
+
+
+    
+
+    

armodel/models/{m2/autosar_templates/common_structure/implementation_data_types.py → M2/AUTOSARTemplates/CommonStructure/ImplementationDataTypes.py}

@@ -1,11 +1,12 @@
 from abc import ABCMeta
 from typing import List
-
-from ...msr.data_dictionary.data_def_properties import SwDataDefProps
-from ....general_structure import Identifiable
-from ....ar_object import ARBoolean, ARLiteral, ARNumerical, ARObject
-from ....datatype import AutosarDataType
-from ..sw_component_template.components import SymbolProps
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical
+from ....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
+from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import AutosarDataType
+from ....M2.AUTOSARTemplates.SWComponentTemplate.Components import SymbolProps
 
 class AbstractImplementationDataTypeElement(Identifiable):
     def __init__(self, parent, short_name: str):

armodel/models/M2/AUTOSARTemplates/CommonStructure/InternalBehavior.py

@@ -0,0 +1,119 @@
+from abc import ABCMeta
+from enum import Enum
+from typing import List
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, RefType
+from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype
+
+class ReentrancyLevelEnum(Enum):
+    multicoreReentrant = "multicoreReentrant"
+    nonReentrant = "nonReentrant"
+    singleCoreReentrant = "singleCoreReentrant"
+
+
+class ExclusiveArea(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+
+class ExecutableEntity(Identifiable, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == ExecutableEntity:
+            raise NotImplementedError("ExecutableEntity is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.activationReason = None                # *
+        self.minimumStartInterval = None            # type: ARFloat
+        self.reentrancyLevel = None                 # 
+        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]  
+        self.swAddrMethodRef = None                 # type: RefType
+
+    def getActivationReason(self):
+        return self.activationReason
+
+    def setActivationReason(self, value):
+        self.activationReason = value
+        return self
+
+    def getMinimumStartInterval(self):
+        return self.minimumStartInterval
+
+    def setMinimumStartInterval(self, value):
+        self.minimumStartInterval = value
+        return self
+
+    def getReentrancyLevel(self):
+        return self.reentrancyLevel
+
+    def setReentrancyLevel(self, value):
+        self.reentrancyLevel = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
+
+    @property
+    def minimumStartIntervalMs(self) -> int:
+        if self.minimumStartInterval is not None:
+            return int(self.minimumStartInterval.getValue() * 1000)
+        return None
+
+    def addCanEnterExclusiveAreaRef(self, ref: RefType):
+        self.canEnterExclusiveAreaRefs.append(ref)
+
+    def getCanEnterExclusiveAreaRefs(self):
+        return self.canEnterExclusiveAreaRefs
+
+
+class InternalBehavior(Identifiable, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == InternalBehavior:
+            raise NotImplementedError("InternalBehavior is an abstract class.")
+        super().__init__(parent, short_name)
+
+        self.data_type_mapping_refs = []        # type: List[RefType]                       
+        self.constant_memories = []             # type: List[ParameterDataPrototype]
+
+    def addDataTypeMappingRef(self, ref: RefType):
+        self.data_type_mapping_refs.append(ref)
+
+    def getDataTypeMappingRefs(self) -> List[RefType]:
+        return self.data_type_mapping_refs
+
+    def createExclusiveArea(self, short_name: str) -> ExclusiveArea:
+        if (short_name not in self.elements):
+            event = ExclusiveArea(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def getExclusiveAreas(self) -> List[ExclusiveArea]:
+        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
+
+    def createConstantMemory(self, short_name: str) -> ParameterDataPrototype:
+        if (short_name not in self.elements):
+            prototype = ParameterDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.constant_memories.append(prototype)
+        return self.elements[short_name]
+
+    def getConstantMemorys(self) -> List[ParameterDataPrototype]:
+        return self.constant_memories
+
+class AbstractEvent(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.activationReasonRepresentationRef = None                       # type: RefType
+
+    def getActivationReasonRepresentationRef(self):
+        return self.activationReasonRepresentationRef
+
+    def setActivationReasonRepresentationRef(self, value):
+        self.activationReasonRepresentationRef = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/ModeDeclaration.py

@@ -0,0 +1,96 @@
+from typing import List
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType, TRefType
+
+class ModeDeclaration(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.value = None                           # type: ARNumerical
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+    def getValue(self) -> ARNumerical:
+        return self.value
+
+
+class ModeRequestTypeMap(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.implementation_data_type_ref = None           # type: RefType
+        self.mode_group_ref = None                        # type: RefType
+
+
+class ModeDeclarationGroup(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._initial_mode_ref = None                      # type: RefType
+        self._on_transition_value = None                   # type: ARNumerical
+
+    def createModeDeclaration(self, short_name: str) -> ModeDeclaration:
+        if (short_name not in self.elements):
+            spec = ModeDeclaration(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
+
+    def getModeDeclarations(self) -> List[ModeDeclaration]:
+        return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key= lambda o:o.short_name))
+
+    def setInitialModeRef(self, ref: RefType):
+        self._initial_mode_ref = ref
+        return self
+
+    def getInitialModeRef(self) -> RefType:
+        return self._initial_mode_ref
+
+    def setOnTransitionValue(self, value):
+        if isinstance(value, int):
+            value = ARNumerical()
+            value.setValue(value)
+        self._on_transition_value = value
+        return self
+
+    def getOnTransitionValue(self) -> ARNumerical:
+        return self._on_transition_value
+
+
+class ModeDeclarationGroupPrototype(Identifiable):
+
+    """
+    The ModeDeclarationGroupPrototype specifies a set of Modes (ModeDeclarationGroup) which is provided or required in the given context.
+    """
+
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._swCalibrationAccess = None        # type: str
+        self.typeTRef = None                    # type: TRefType
+
+    @property
+    def sw_calibration_access(self):
+        return self._swCalibrationAccess
+
+    @sw_calibration_access.setter
+    def sw_calibration_access(self, value):
+        if (value not in ("notAccessible", "readOnly", "readWrite")):
+            raise ValueError("Invalid SwCalibrationAccess <%s> of ModeDeclarationGroupPrototype <%s>" % (value, self.short_name))
+        self._swCalibrationAccess = value
+
+    def getSwCalibrationAccess(self):
+        return self.swCalibrationAccess
+
+    def setSwCalibrationAccess(self, value):
+        self.swCalibrationAccess = value
+        return self
+
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/MemorySectionUsage.py

@@ -0,0 +1,69 @@
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+import re
+from typing import List
+
+class MemorySection(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._alignment = None              # type: ARLiteral
+        self.size = None
+        self.options = []                   # type: List[ARLiteral]
+        self.swAddrMethodRef = None         # type: RefType
+        self.symbol = None                  # type: ARLiteral
+
+    def getAlignment(self):
+        return self.alignment
+
+    def setAlignment(self, value):
+        self.alignment = value
+        return self
+
+    def getSize(self):
+        return self.size
+
+    def setSize(self, value):
+        self.size = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
+
+    @property
+    def alignment(self) -> ARLiteral:
+        return self._alignment
+
+    @alignment.setter
+    def alignment(self, value: ARLiteral):
+        if value is not None and value.getValue() != "":
+            match = False
+            if value.getValue() in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
+                self._alignment = value
+                match = True
+            else:
+                m = re.match(r'^\d+', value.value)
+                if m:
+                    self._alignment = value
+                    match = True
+
+            if not match:
+                raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.getShortName()))
+
+    def addOption(self, option: ARLiteral):
+        self.options.append(option)
+
+    def getOptions(self) -> List[ARLiteral]:
+        return self.options